"github.com/modelcontextprotocol/go-sdk/mcp"

// GetCurrentTime implements the get_current_time tool handler
// It returns the current system time with timezone information
func GetCurrentTime(ctx context.Context, req *mcp.CallToolRequest, input GetCurrentTimeInput) (
	*mcp.CallToolResult,
	GetCurrentTimeOutput,
	error,
) {
	// Get current time

// GetCurrentTime returns the current system time with timezone information
func GetCurrentTime(ctx context.Context, input GetCurrentTimeInput) (GetCurrentTimeOutput, error) {

	// Create output structure

	// Return successful result with output
	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// ExecuteSQL implements the execute_sql tool handler
// Executes arbitrary SQL SELECT queries with safety validation

// ExecuteSQL executes arbitrary SQL SELECT queries with safety validation

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, ExecuteSQLOutput, error) {

) (ExecuteSQLOutput, error) {

		return nil, ExecuteSQLOutput{}, fmt.Errorf("query cannot be empty")

		return ExecuteSQLOutput{}, fmt.Errorf("query cannot be empty")

		return nil, ExecuteSQLOutput{}, fmt.Errorf("only SELECT and WITH queries are allowed")

		return ExecuteSQLOutput{}, fmt.Errorf("only SELECT and WITH queries are allowed")

		return nil, ExecuteSQLOutput{}, fmt.Errorf("query contains forbidden keywords (INSERT/UPDATE/DELETE/DROP/CREATE/ALTER)")

		return ExecuteSQLOutput{}, fmt.Errorf("query contains forbidden keywords (INSERT/UPDATE/DELETE/DROP/CREATE/ALTER)")

			return nil, ExecuteSQLOutput{}, fmt.Errorf("limit must be between 1 and %d", maxLimit)

			return ExecuteSQLOutput{}, fmt.Errorf("limit must be between 1 and %d", maxLimit)

		return nil, ExecuteSQLOutput{}, fmt.Errorf("database connection failed: %w", err)

		return ExecuteSQLOutput{}, fmt.Errorf("database connection failed: %w", err)

		return nil, ExecuteSQLOutput{}, fmt.Errorf("query execution failed: %w", err)

		return ExecuteSQLOutput{}, fmt.Errorf("query execution failed: %w", err)

		return nil, ExecuteSQLOutput{}, fmt.Errorf("failed to get columns: %w", err)

		return ExecuteSQLOutput{}, fmt.Errorf("failed to get columns: %w", err)

		return nil, ExecuteSQLOutput{}, fmt.Errorf("failed to get column types: %w", err)

		return ExecuteSQLOutput{}, fmt.Errorf("failed to get column types: %w", err)

			return nil, ExecuteSQLOutput{}, fmt.Errorf("row scan failed: %w", err)

			return ExecuteSQLOutput{}, fmt.Errorf("row scan failed: %w", err)

		return nil, ExecuteSQLOutput{}, fmt.Errorf("row iteration failed: %w", err)

		return ExecuteSQLOutput{}, fmt.Errorf("row iteration failed: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

		result, output, err := CreateOrUpdatePattern(ctx, &mcp.CallToolRequest{}, input)

		output, err := CreateOrUpdatePattern(ctx, input)

		}
		if result == nil {
			t.Fatal("Expected non-nil result")

		result, output, err := CreateOrUpdatePattern(ctx, &mcp.CallToolRequest{}, input)

		output, err := CreateOrUpdatePattern(ctx, input)

		if result == nil {
			t.Fatal("Expected non-nil result")
		}

		result2, output2, err2 := CreateOrUpdatePattern(ctx, &mcp.CallToolRequest{}, input)

		output2, err2 := CreateOrUpdatePattern(ctx, input)

		}
		if result2 == nil {
			t.Fatal("Expected non-nil result")

			_, _, err := CreateOrUpdatePattern(ctx, &mcp.CallToolRequest{}, input)

			_, err := CreateOrUpdatePattern(ctx, input)

		_, _, err := CreateOrUpdatePattern(ctx, &mcp.CallToolRequest{}, input)

		_, err := CreateOrUpdatePattern(ctx, input)

		_, _, err := CreateOrUpdatePattern(ctx, &mcp.CallToolRequest{}, input)

		_, err := CreateOrUpdatePattern(ctx, input)

	"github.com/modelcontextprotocol/go-sdk/mcp"

// CreateOrUpdatePattern implements the create_or_update_pattern tool handler

// CreateOrUpdatePattern creates a new recording pattern or updates an existing one

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, PatternOutput, error) {

) (PatternOutput, error) {

func createPattern(ctx context.Context, input PatternInput) (*mcp.CallToolResult, PatternOutput, error) {

func createPattern(ctx context.Context, input PatternInput) (PatternOutput, error) {

		return nil, output, fmt.Errorf("record_seconds is required when creating a pattern")

		return output, fmt.Errorf("record_seconds is required when creating a pattern")

		return nil, output, fmt.Errorf("sleep_seconds is required when creating a pattern")

		return output, fmt.Errorf("sleep_seconds is required when creating a pattern")

		return nil, output, fmt.Errorf("record_seconds must be positive (got %d)", *input.RecordSeconds)

		return output, fmt.Errorf("record_seconds must be positive (got %d)", *input.RecordSeconds)

		return nil, output, fmt.Errorf("sleep_seconds must be positive (got %d)", *input.SleepSeconds)

		return output, fmt.Errorf("sleep_seconds must be positive (got %d)", *input.SleepSeconds)

		return nil, output, fmt.Errorf("database connection failed: %w", err)

		return output, fmt.Errorf("database connection failed: %w", err)

		return nil, output, fmt.Errorf("failed to begin transaction: %w", err)

		return output, fmt.Errorf("failed to begin transaction: %w", err)

			return nil, output, fmt.Errorf("failed to fetch existing pattern: %w", err)

			return output, fmt.Errorf("failed to fetch existing pattern: %w", err)

			return nil, output, fmt.Errorf("failed to commit transaction: %w", err)

			return output, fmt.Errorf("failed to commit transaction: %w", err)

		return &mcp.CallToolResult{}, output, nil

		return output, nil

		return nil, output, fmt.Errorf("failed to check for existing pattern: %w", err)

		return output, fmt.Errorf("failed to check for existing pattern: %w", err)

		return nil, output, fmt.Errorf("failed to generate ID: %w", err)

		return output, fmt.Errorf("failed to generate ID: %w", err)

		return nil, output, fmt.Errorf("failed to create pattern: %w", err)

		return output, fmt.Errorf("failed to create pattern: %w", err)

		return nil, output, fmt.Errorf("failed to fetch created pattern: %w", err)

		return output, fmt.Errorf("failed to fetch created pattern: %w", err)

		return nil, output, fmt.Errorf("failed to commit transaction: %w", err)

		return output, fmt.Errorf("failed to commit transaction: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

func updatePattern(ctx context.Context, input PatternInput) (*mcp.CallToolResult, PatternOutput, error) {

func updatePattern(ctx context.Context, input PatternInput) (PatternOutput, error) {

		return nil, output, fmt.Errorf("record_seconds must be greater than 0: %d", *input.RecordSeconds)

		return output, fmt.Errorf("record_seconds must be greater than 0: %d", *input.RecordSeconds)

		return nil, output, fmt.Errorf("sleep_seconds must be greater than or equal to 0: %d", *input.SleepSeconds)

		return output, fmt.Errorf("sleep_seconds must be greater than or equal to 0: %d", *input.SleepSeconds)

		return nil, output, fmt.Errorf("failed to open database: %w", err)

		return output, fmt.Errorf("failed to open database: %w", err)

		return nil, output, fmt.Errorf("failed to query pattern: %w", err)

		return output, fmt.Errorf("failed to query pattern: %w", err)

		return nil, output, fmt.Errorf("pattern not found: %s", patternID)

		return output, fmt.Errorf("pattern not found: %s", patternID)

		return nil, output, fmt.Errorf("no fields provided to update")

		return output, fmt.Errorf("no fields provided to update")

		return nil, output, fmt.Errorf("failed to update pattern: %w", err)

		return output, fmt.Errorf("failed to update pattern: %w", err)

		return nil, output, fmt.Errorf("failed to fetch updated pattern: %w", err)

		return output, fmt.Errorf("failed to fetch updated pattern: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// CreateOrUpdateLocation implements the create_or_update_location tool handler

// CreateOrUpdateLocation creates a new location or updates an existing one

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, LocationOutput, error) {

) (LocationOutput, error) {

func createLocation(ctx context.Context, input LocationInput) (*mcp.CallToolResult, LocationOutput, error) {

func createLocation(ctx context.Context, input LocationInput) (LocationOutput, error) {

		return nil, output, fmt.Errorf("dataset_id is required when creating a location")

		return output, fmt.Errorf("dataset_id is required when creating a location")

		return nil, output, fmt.Errorf("name is required when creating a location")

		return output, fmt.Errorf("name is required when creating a location")

		return nil, output, fmt.Errorf("latitude is required when creating a location")

		return output, fmt.Errorf("latitude is required when creating a location")

		return nil, output, fmt.Errorf("longitude is required when creating a location")

		return output, fmt.Errorf("longitude is required when creating a location")

		return nil, output, fmt.Errorf("timezone_id is required when creating a location")

		return output, fmt.Errorf("timezone_id is required when creating a location")

		return nil, output, err

		return output, err

		return nil, output, fmt.Errorf("database connection failed: %w", err)

		return output, fmt.Errorf("database connection failed: %w", err)

		return nil, output, fmt.Errorf("failed to begin transaction: %w", err)

		return output, fmt.Errorf("failed to begin transaction: %w", err)

		return nil, output, fmt.Errorf("failed to verify dataset: %w", err)

		return output, fmt.Errorf("failed to verify dataset: %w", err)

		return nil, output, fmt.Errorf("dataset with ID '%s' does not exist", *input.DatasetID)

		return output, fmt.Errorf("dataset with ID '%s' does not exist", *input.DatasetID)

		return nil, output, fmt.Errorf("dataset '%s' (ID: %s) is not active", datasetName, *input.DatasetID)

		return output, fmt.Errorf("dataset '%s' (ID: %s) is not active", datasetName, *input.DatasetID)

		return nil, output, fmt.Errorf("failed to generate ID: %w", err)

		return output, fmt.Errorf("failed to generate ID: %w", err)

		return nil, output, fmt.Errorf("failed to create location: %w", err)

		return output, fmt.Errorf("failed to create location: %w", err)

		return nil, output, fmt.Errorf("failed to fetch created location: %w", err)

		return output, fmt.Errorf("failed to fetch created location: %w", err)

		return nil, output, fmt.Errorf("failed to commit transaction: %w", err)

		return output, fmt.Errorf("failed to commit transaction: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

func updateLocation(ctx context.Context, input LocationInput) (*mcp.CallToolResult, LocationOutput, error) {

func updateLocation(ctx context.Context, input LocationInput) (LocationOutput, error) {

		return nil, output, err

		return output, err

		return nil, output, fmt.Errorf("failed to open database: %w", err)

		return output, fmt.Errorf("failed to open database: %w", err)

		return nil, output, fmt.Errorf("failed to query location: %w", err)

		return output, fmt.Errorf("failed to query location: %w", err)

		return nil, output, fmt.Errorf("location not found: %s", locationID)

		return output, fmt.Errorf("location not found: %s", locationID)

			return nil, output, fmt.Errorf("failed to query dataset: %w", err)

			return output, fmt.Errorf("failed to query dataset: %w", err)

			return nil, output, fmt.Errorf("dataset not found: %s", *input.DatasetID)

			return output, fmt.Errorf("dataset not found: %s", *input.DatasetID)

		return nil, output, fmt.Errorf("no fields provided to update")

		return output, fmt.Errorf("no fields provided to update")

		return nil, output, fmt.Errorf("failed to update location: %w", err)

		return output, fmt.Errorf("failed to update location: %w", err)

		return nil, output, fmt.Errorf("failed to fetch updated location: %w", err)

		return output, fmt.Errorf("failed to fetch updated location: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

		result, output, err := ExecuteSQL(ctx, &mcp.CallToolRequest{}, input)

		output, err := ExecuteSQL(ctx, input)

		if result == nil {
			t.Fatal("Expected non-nil result")
		}

		_, datasetOutput, err := ExecuteSQL(ctx, &mcp.CallToolRequest{}, datasetSQL)

		datasetOutput, err := ExecuteSQL(ctx, datasetSQL)

		_, locationOutput, err := ExecuteSQL(ctx, &mcp.CallToolRequest{}, locationSQL)

		locationOutput, err := ExecuteSQL(ctx, locationSQL)

		result, output, err := CreateOrUpdateCluster(ctx, &mcp.CallToolRequest{}, input)

		output, err := CreateOrUpdateCluster(ctx, input)

		if result == nil {
			t.Fatal("Expected non-nil result")
		}

		sqlResult, sqlOutput, err := ExecuteSQL(ctx, &mcp.CallToolRequest{}, sqlInput)

		sqlOutput, err := ExecuteSQL(ctx, sqlInput)

		}
		if sqlResult == nil {
			t.Fatal("Expected non-nil result")

		// SQL tool returns all values as strings, interface{}, or native types depending on DuckDB driver

		// Check record_s and sleep_s (can be string or int types)

		// Check record_s and sleep_s

		// Just verify they're not nil/empty

	"github.com/modelcontextprotocol/go-sdk/mcp"

// ImportMLSelections implements the import_ml_selections MCP tool

// ImportMLSelections imports ML-detected kiwi call selections from folder structure

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, ImportMLSelectionsOutput, error) {

) (ImportMLSelectionsOutput, error) {

		return nil, output, fmt.Errorf("invalid folder name: %w", err)

		return output, fmt.Errorf("invalid folder name: %w", err)

		return nil, output, fmt.Errorf("folder does not exist: %s", input.FolderPath)

		return output, fmt.Errorf("folder does not exist: %s", input.FolderPath)

		return nil, output, fmt.Errorf("validation failed: %w", err)

		return output, fmt.Errorf("validation failed: %w", err)

		return &mcp.CallToolResult{}, output, nil

		return output, nil

		return &mcp.CallToolResult{}, output, nil

		return output, nil

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// ImportAudioFiles implements the import_audio_files MCP tool

// ImportAudioFiles imports WAV files from a folder into the database

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, ImportAudioFilesOutput, error) {

) (ImportAudioFilesOutput, error) {

		return nil, output, fmt.Errorf("validation failed: %w", err)

		return output, fmt.Errorf("validation failed: %w", err)

		return nil, output, fmt.Errorf("failed to open database: %w", err)

		return output, fmt.Errorf("failed to open database: %w", err)

		return nil, output, fmt.Errorf("failed to set cluster path: %w", err)

		return output, fmt.Errorf("failed to set cluster path: %w", err)

		return nil, output, fmt.Errorf("cluster import failed: %w", err)

		return output, fmt.Errorf("cluster import failed: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// ImportFile implements the import_file MCP tool
// Imports a single WAV audio file into the database with full metadata extraction

// ImportFile imports a single WAV audio file into the database with full metadata extraction

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, ImportFileOutput, error) {

) (ImportFileOutput, error) {

		return nil, output, fmt.Errorf("file validation failed: %w", err)

		return output, fmt.Errorf("file validation failed: %w", err)

		return nil, output, fmt.Errorf("hierarchy validation failed: %w", err)

		return output, fmt.Errorf("hierarchy validation failed: %w", err)

		return nil, output, fmt.Errorf("failed to get location data: %w", err)

		return output, fmt.Errorf("failed to get location data: %w", err)

		return nil, output, fmt.Errorf("file processing failed: %w", err)

		return output, fmt.Errorf("file processing failed: %w", err)

		return nil, output, fmt.Errorf("failed to set cluster path: %w", err)

		return output, fmt.Errorf("failed to set cluster path: %w", err)

		return nil, output, fmt.Errorf("database insertion failed: %w", err)

		return output, fmt.Errorf("database insertion failed: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// CreateOrUpdateDataset implements the create_or_update_dataset tool handler

// CreateOrUpdateDataset creates a new dataset or updates an existing one

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, DatasetOutput, error) {

) (DatasetOutput, error) {

func createDataset(ctx context.Context, input DatasetInput) (*mcp.CallToolResult, DatasetOutput, error) {

func createDataset(ctx context.Context, input DatasetInput) (DatasetOutput, error) {

		return nil, output, fmt.Errorf("name is required when creating a dataset")

		return output, fmt.Errorf("name is required when creating a dataset")

		return nil, output, fmt.Errorf("name must be 255 characters or less (got %d)", len(*input.Name))

		return output, fmt.Errorf("name must be 255 characters or less (got %d)", len(*input.Name))

		return nil, output, fmt.Errorf("description must be 255 characters or less (got %d)", len(*input.Description))

		return output, fmt.Errorf("description must be 255 characters or less (got %d)", len(*input.Description))

			return nil, output, fmt.Errorf("invalid type '%s': must be 'organise', 'test', or 'train'", *input.Type)

			return output, fmt.Errorf("invalid type '%s': must be 'organise', 'test', or 'train'", *input.Type)

		return nil, output, fmt.Errorf("database connection failed: %w", err)

		return output, fmt.Errorf("database connection failed: %w", err)

		return nil, output, fmt.Errorf("failed to begin transaction: %w", err)

		return output, fmt.Errorf("failed to begin transaction: %w", err)

		return nil, output, fmt.Errorf("failed to generate ID: %w", err)

		return output, fmt.Errorf("failed to generate ID: %w", err)

		return nil, output, fmt.Errorf("failed to create dataset: %w", err)

		return output, fmt.Errorf("failed to create dataset: %w", err)

		return nil, output, fmt.Errorf("failed to fetch created dataset: %w", err)

		return output, fmt.Errorf("failed to fetch created dataset: %w", err)

		return nil, output, fmt.Errorf("failed to commit transaction: %w", err)

		return output, fmt.Errorf("failed to commit transaction: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

func updateDataset(ctx context.Context, input DatasetInput) (*mcp.CallToolResult, DatasetOutput, error) {

func updateDataset(ctx context.Context, input DatasetInput) (DatasetOutput, error) {

		return nil, output, fmt.Errorf("name must be 255 characters or less (got %d)", len(*input.Name))

		return output, fmt.Errorf("name must be 255 characters or less (got %d)", len(*input.Name))

		return nil, output, fmt.Errorf("description must be 255 characters or less (got %d)", len(*input.Description))

		return output, fmt.Errorf("description must be 255 characters or less (got %d)", len(*input.Description))

			return nil, output, fmt.Errorf("invalid dataset type: %s (must be 'organise', 'test', or 'train')", *input.Type)

			return output, fmt.Errorf("invalid dataset type: %s (must be 'organise', 'test', or 'train')", *input.Type)

		return nil, output, fmt.Errorf("failed to open database: %w", err)

		return output, fmt.Errorf("failed to open database: %w", err)

		return nil, output, fmt.Errorf("failed to query dataset: %w", err)

		return output, fmt.Errorf("failed to query dataset: %w", err)

		return nil, output, fmt.Errorf("dataset not found: %s", datasetID)

		return output, fmt.Errorf("dataset not found: %s", datasetID)

		return nil, output, fmt.Errorf("no fields provided to update")

		return output, fmt.Errorf("no fields provided to update")

		return nil, output, fmt.Errorf("failed to update dataset: %w", err)

		return output, fmt.Errorf("failed to update dataset: %w", err)

		return nil, output, fmt.Errorf("failed to fetch updated dataset: %w", err)

		return output, fmt.Errorf("failed to fetch updated dataset: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// CreateOrUpdateCluster implements the create_or_update_cluster tool handler

// CreateOrUpdateCluster creates a new cluster or updates an existing one

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, ClusterOutput, error) {

) (ClusterOutput, error) {

func createCluster(ctx context.Context, input ClusterInput) (*mcp.CallToolResult, ClusterOutput, error) {

func createCluster(ctx context.Context, input ClusterInput) (ClusterOutput, error) {

		return nil, output, fmt.Errorf("dataset_id is required when creating a cluster")

		return output, fmt.Errorf("dataset_id is required when creating a cluster")

		return nil, output, fmt.Errorf("location_id is required when creating a cluster")

		return output, fmt.Errorf("location_id is required when creating a cluster")

		return nil, output, fmt.Errorf("name is required when creating a cluster")

		return output, fmt.Errorf("name is required when creating a cluster")

		return nil, output, fmt.Errorf("sample_rate is required when creating a cluster")

		return output, fmt.Errorf("sample_rate is required when creating a cluster")

		return nil, output, err

		return output, err

		return nil, output, fmt.Errorf("database connection failed: %w", err)

		return output, fmt.Errorf("database connection failed: %w", err)

		return nil, output, fmt.Errorf("failed to begin transaction: %w", err)

		return output, fmt.Errorf("failed to begin transaction: %w", err)

		return nil, output, fmt.Errorf("failed to verify dataset: %w", err)

		return output, fmt.Errorf("failed to verify dataset: %w", err)

		return nil, output, fmt.Errorf("dataset with ID '%s' does not exist", *input.DatasetID)

		return output, fmt.Errorf("dataset with ID '%s' does not exist", *input.DatasetID)

		return nil, output, fmt.Errorf("dataset '%s' (ID: %s) is not active", datasetName, *input.DatasetID)

		return output, fmt.Errorf("dataset '%s' (ID: %s) is not active", datasetName, *input.DatasetID)

		return nil, output, fmt.Errorf("failed to verify location: %w", err)

		return output, fmt.Errorf("failed to verify location: %w", err)

		return nil, output, fmt.Errorf("location with ID '%s' does not exist", *input.LocationID)

		return output, fmt.Errorf("location with ID '%s' does not exist", *input.LocationID)

		return nil, output, fmt.Errorf("location '%s' (ID: %s) is not active", locationName, *input.LocationID)

		return output, fmt.Errorf("location '%s' (ID: %s) is not active", locationName, *input.LocationID)

		return nil, output, fmt.Errorf("location '%s' (ID: %s) does not belong to dataset '%s' (ID: %s) - it belongs to dataset ID '%s'",

		return output, fmt.Errorf("location '%s' (ID: %s) does not belong to dataset '%s' (ID: %s) - it belongs to dataset ID '%s'",

			return nil, output, fmt.Errorf("failed to verify cyclic recording pattern: %w", err)

			return output, fmt.Errorf("failed to verify cyclic recording pattern: %w", err)

			return nil, output, fmt.Errorf("cyclic recording pattern with ID '%s' does not exist", *input.CyclicRecordingPatternID)

			return output, fmt.Errorf("cyclic recording pattern with ID '%s' does not exist", *input.CyclicRecordingPatternID)

			return nil, output, fmt.Errorf("cyclic recording pattern with ID '%s' is not active", *input.CyclicRecordingPatternID)

			return output, fmt.Errorf("cyclic recording pattern with ID '%s' is not active", *input.CyclicRecordingPatternID)

		return nil, output, fmt.Errorf("failed to generate ID: %w", err)

		return output, fmt.Errorf("failed to generate ID: %w", err)

		return nil, output, fmt.Errorf("failed to create cluster: %w", err)

		return output, fmt.Errorf("failed to create cluster: %w", err)

		return nil, output, fmt.Errorf("failed to fetch created cluster: %w", err)

		return output, fmt.Errorf("failed to fetch created cluster: %w", err)

		return nil, output, fmt.Errorf("failed to commit transaction: %w", err)

		return output, fmt.Errorf("failed to commit transaction: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

func updateCluster(ctx context.Context, input ClusterInput) (*mcp.CallToolResult, ClusterOutput, error) {

func updateCluster(ctx context.Context, input ClusterInput) (ClusterOutput, error) {

		return nil, output, err

		return output, err

		return nil, output, fmt.Errorf("failed to open database: %w", err)

		return output, fmt.Errorf("failed to open database: %w", err)

		return nil, output, fmt.Errorf("failed to query cluster: %w", err)

		return output, fmt.Errorf("failed to query cluster: %w", err)

		return nil, output, fmt.Errorf("cluster not found: %s", clusterID)

		return output, fmt.Errorf("cluster not found: %s", clusterID)

				return nil, output, fmt.Errorf("failed to verify cyclic recording pattern: %w", err)

				return output, fmt.Errorf("failed to verify cyclic recording pattern: %w", err)

				return nil, output, fmt.Errorf("cyclic recording pattern not found or not active: %s", trimmedPatternID)

				return output, fmt.Errorf("cyclic recording pattern not found or not active: %s", trimmedPatternID)

		return nil, output, fmt.Errorf("no fields provided to update")

		return output, fmt.Errorf("no fields provided to update")

		return nil, output, fmt.Errorf("failed to update cluster: %w", err)

		return output, fmt.Errorf("failed to update cluster: %w", err)

		return nil, output, fmt.Errorf("failed to fetch updated cluster: %w", err)

		return output, fmt.Errorf("failed to fetch updated cluster: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"github.com/modelcontextprotocol/go-sdk/mcp"

// BulkFileImport implements the bulk_file_import MCP tool

// BulkFileImport imports WAV files across multiple locations/clusters using a CSV file

	req *mcp.CallToolRequest,

) (*mcp.CallToolResult, BulkFileImportOutput, error) {

) (BulkFileImportOutput, error) {

		return nil, output, fmt.Errorf("failed to open log file: %w", err)

		return output, fmt.Errorf("failed to open log file: %w", err)

		return nil, output, fmt.Errorf("validation failed: %w", err)

		return output, fmt.Errorf("validation failed: %w", err)

		return nil, output, fmt.Errorf("failed to read CSV: %w", err)

		return output, fmt.Errorf("failed to read CSV: %w", err)

		return nil, output, fmt.Errorf("failed to open database: %w", err)

		return output, fmt.Errorf("failed to open database: %w", err)

				return nil, output, fmt.Errorf("failed to create cluster: %w", err)

				return output, fmt.Errorf("failed to create cluster: %w", err)

			return nil, output, fmt.Errorf("failed to check cluster: %w", err)

			return output, fmt.Errorf("failed to check cluster: %w", err)

			return nil, output, fmt.Errorf("failed to import files: %w", err)

			return output, fmt.Errorf("failed to import files: %w", err)

	return &mcp.CallToolResult{}, output, nil

	return output, nil

	"context"

	"log"

	"path/filepath"
	"skraak/prompts"
	"skraak/resources"
	"skraak/tools"

	"github.com/modelcontextprotocol/go-sdk/mcp"

	"skraak/cmd"

// dbPath stores the path to the DuckDB database
var dbPath string

	// Parse command line arguments
	// os.Args[0] is the program name
	// os.Args[1] should be the subcommand

		runMCP()

		cmd.RunMCP(os.Args[2:])
	case "import":
		cmd.RunImport(os.Args[2:])
	case "sql":
		cmd.RunSQL(os.Args[2:])

	fmt.Fprintf(os.Stderr, "  mcp <path-to-duckdb-database>    Start MCP server (stdio transport)\n\n")
	fmt.Fprintf(os.Stderr, "Example:\n")

	fmt.Fprintf(os.Stderr, "  mcp <db-path>                          Start MCP server (stdio transport)\n")
	fmt.Fprintf(os.Stderr, "  import bulk --db <db> --dataset <id> --csv <path> --log <path>   Bulk import from CSV\n")
	fmt.Fprintf(os.Stderr, "  sql --db <db> <query>                  Execute SQL query\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")

	fmt.Fprintf(os.Stderr, "  %s import bulk --db ./db/skraak.duckdb --dataset abc123 --csv import.csv --log progress.log\n", os.Args[0])
	fmt.Fprintf(os.Stderr, "  %s sql --db ./db/skraak.duckdb \"SELECT COUNT(*) FROM file WHERE active = true\"\n", os.Args[0])

func runMCP() {
	if len(os.Args) != 3 {
		fmt.Fprintf(os.Stderr, "Usage: %s mcp <path-to-duckdb-database>\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "Example: %s mcp ./db/skraak.duckdb\n", os.Args[0])
		os.Exit(1)
	}
	dbPath = os.Args[2]
	// Set database path for tools package
	tools.SetDBPath(dbPath)
	// Set schema path for resources package
	schemaPath := filepath.Join(filepath.Dir(os.Args[0]), "db", "schema.sql")
	resources.SetSchemaPath(schemaPath)
	// Create MCP server with metadata
	server := mcp.NewServer(&mcp.Implementation{
		Name:    "skraak",
		Version: "v1.0.0",
	}, nil)
	// Register the get_current_time tool
	mcp.AddTool(server, &mcp.Tool{
		Name:        "get_current_time",
		Description: "Get the current system time with timezone information",
	}, tools.GetCurrentTime)
	// Register the generic SQL query tool
	mcp.AddTool(server, &mcp.Tool{
		Name:        "execute_sql",
		Description: "Execute arbitrary SQL SELECT queries against the database. Supports parameterized queries with ? placeholders. Database is read-only. Results limited to 1000 rows by default (max 10000). Use with schema resources to construct queries.",
	}, tools.ExecuteSQL)
	// Register create-or-update tools
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_dataset",
		Description: "Create or update a dataset. Omit 'id' to create (name required), provide 'id' to update. Returns the dataset with timestamps.",
	}, tools.CreateOrUpdateDataset)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_location",
		Description: "Create or update a location. Omit 'id' to create (dataset_id, name, latitude, longitude, timezone_id required), provide 'id' to update. Location must belong to the specified dataset when creating.",
	}, tools.CreateOrUpdateLocation)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_cluster",
		Description: "Create or update a cluster. Omit 'id' to create (dataset_id, location_id, name, sample_rate required), provide 'id' to update. Query existing patterns first with execute_sql before setting cyclic_recording_pattern_id.",
	}, tools.CreateOrUpdateCluster)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_pattern",
		Description: "Create or update a cyclic recording pattern. Omit 'id' to create (record_seconds, sleep_seconds required), provide 'id' to update. Returns existing pattern if duplicate record/sleep values found.",
	}, tools.CreateOrUpdatePattern)
	// Register import single file
	mcp.AddTool(server, &mcp.Tool{
		Name:        "import_file",
		Description: "Import a single WAV file into the database. Automatically parses AudioMoth and filename timestamps, calculates hash, extracts metadata, and computes astronomical data. Skips if duplicate (by hash).",
	}, tools.ImportFile)
	// Register import audio files
	mcp.AddTool(server, &mcp.Tool{
		Name:        "import_audio_files",
		Description: "Batch import WAV files from a folder into the database. Automatically parses AudioMoth and filename timestamps, calculates hashes, extracts metadata, and computes astronomical data. Files are imported in a single transaction. Duplicate files (by hash) are skipped.",
	}, tools.ImportAudioFiles)
	// Register bulk file import
	mcp.AddTool(server, &mcp.Tool{
		Name:        "bulk_file_import",
		Description: "Batch import WAV files across multiple locations/clusters using a CSV file. CSV must have columns (in order): location_name, location_id, directory_path, date_range, sample_rate, file_count. Auto-creates clusters using date_range as cluster name. Logs progress to file for monitoring. Synchronous/fail-fast execution.",
	}, tools.BulkFileImport)
	// Register import ML selections
	mcp.AddTool(server, &mcp.Tool{
		Name:        "import_ml_selections",
		Description: "Import hand sorted ML-detected kiwi call selections from folder structure organized by species/call-type with WAV/PNG pairs",
	}, tools.ImportMLSelections)
	// Register schema resources
	schemaResource, schemaTemplate := resources.GetSchemaResources()
	server.AddResource(schemaResource, resources.SchemaResourceHandler)
	server.AddResourceTemplate(schemaTemplate, resources.SchemaResourceHandler)
	// Register prompts
	server.AddPrompt(prompts.GetQueryDatasetsPrompt(), prompts.QueryDatasetsPromptHandler)
	server.AddPrompt(prompts.GetExploreSchemaPrompt(), prompts.ExploreSchemaPromptHandler)
	server.AddPrompt(prompts.GetExploreLocationHierarchyPrompt(), prompts.ExploreLocationHierarchyPromptHandler)
	server.AddPrompt(prompts.GetQueryLocationDataPrompt(), prompts.QueryLocationDataPromptHandler)
	server.AddPrompt(prompts.GetAnalyzeClusterFilesPrompt(), prompts.AnalyzeClusterFilesPromptHandler)
	server.AddPrompt(prompts.GetSystemStatusPrompt(), prompts.SystemStatusPromptHandler)
	// Run the server on stdio transport
	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
		log.Fatalf("Server error: %v", err)
	}
}

package cmd
import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"strings"
	"skraak/tools"
)
// RunSQL handles the "sql" subcommand
func RunSQL(args []string) {
	fs := flag.NewFlagSet("sql", flag.ExitOnError)
	dbPath := fs.String("db", "", "Path to DuckDB database (required)")
	limit := fs.Int("limit", 0, "Maximum rows to return (default 1000, max 10000)")
	fs.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: skraak sql --db <path> [options] <query>\n\n")
		fmt.Fprintf(os.Stderr, "Execute a SQL SELECT query against the database.\n\n")
		fmt.Fprintf(os.Stderr, "Options:\n")
		fs.PrintDefaults()
		fmt.Fprintf(os.Stderr, "\nExamples:\n")
		fmt.Fprintf(os.Stderr, "  skraak sql --db ./db/skraak.duckdb \"SELECT COUNT(*) FROM file WHERE active = true\"\n")
		fmt.Fprintf(os.Stderr, "  skraak sql --db ./db/skraak.duckdb --limit 10 \"SELECT * FROM dataset\"\n")
	}
	if err := fs.Parse(args); err != nil {
		os.Exit(1)
	}
	if *dbPath == "" {
		fmt.Fprintf(os.Stderr, "Error: --db is required\n\n")
		fs.Usage()
		os.Exit(1)
	}
	// Remaining args are the query
	remaining := fs.Args()
	if len(remaining) == 0 {
		fmt.Fprintf(os.Stderr, "Error: query is required\n\n")
		fs.Usage()
		os.Exit(1)
	}
	query := strings.Join(remaining, " ")
	tools.SetDBPath(*dbPath)
	input := tools.ExecuteSQLInput{
		Query: query,
	}
	if *limit > 0 {
		input.Limit = limit
	}
	output, err := tools.ExecuteSQL(context.Background(), input)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
	enc := json.NewEncoder(os.Stdout)
	enc.SetIndent("", "  ")
	enc.Encode(output)
}

package cmd
import (
	"context"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"skraak/prompts"
	"skraak/resources"
	"skraak/tools"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)
// RunMCP starts the MCP server on stdio transport
func RunMCP(args []string) {
	if len(args) != 1 {
		fmt.Fprintf(os.Stderr, "Usage: skraak mcp <path-to-duckdb-database>\n")
		fmt.Fprintf(os.Stderr, "Example: skraak mcp ./db/skraak.duckdb\n")
		os.Exit(1)
	}
	dbPath := args[0]
	tools.SetDBPath(dbPath)
	// Set schema path for resources package
	schemaPath := filepath.Join(filepath.Dir(os.Args[0]), "db", "schema.sql")
	resources.SetSchemaPath(schemaPath)
	// Create MCP server
	server := mcp.NewServer(&mcp.Implementation{
		Name:    "skraak",
		Version: "v1.0.0",
	}, nil)
	// Register tools (thin adapters that bridge MCP types to core functions)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "get_current_time",
		Description: "Get the current system time with timezone information",
	}, mcpGetCurrentTime)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "execute_sql",
		Description: "Execute arbitrary SQL SELECT queries against the database. Supports parameterized queries with ? placeholders. Database is read-only. Results limited to 1000 rows by default (max 10000). Use with schema resources to construct queries.",
	}, mcpExecuteSQL)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_dataset",
		Description: "Create or update a dataset. Omit 'id' to create (name required), provide 'id' to update. Returns the dataset with timestamps.",
	}, mcpCreateOrUpdateDataset)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_location",
		Description: "Create or update a location. Omit 'id' to create (dataset_id, name, latitude, longitude, timezone_id required), provide 'id' to update. Location must belong to the specified dataset when creating.",
	}, mcpCreateOrUpdateLocation)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_cluster",
		Description: "Create or update a cluster. Omit 'id' to create (dataset_id, location_id, name, sample_rate required), provide 'id' to update. Query existing patterns first with execute_sql before setting cyclic_recording_pattern_id.",
	}, mcpCreateOrUpdateCluster)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "create_or_update_pattern",
		Description: "Create or update a cyclic recording pattern. Omit 'id' to create (record_seconds, sleep_seconds required), provide 'id' to update. Returns existing pattern if duplicate record/sleep values found.",
	}, mcpCreateOrUpdatePattern)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "import_file",
		Description: "Import a single WAV file into the database. Automatically parses AudioMoth and filename timestamps, calculates hash, extracts metadata, and computes astronomical data. Skips if duplicate (by hash).",
	}, mcpImportFile)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "import_audio_files",
		Description: "Batch import WAV files from a folder into the database. Automatically parses AudioMoth and filename timestamps, calculates hashes, extracts metadata, and computes astronomical data. Files are imported in a single transaction. Duplicate files (by hash) are skipped.",
	}, mcpImportAudioFiles)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "bulk_file_import",
		Description: "Batch import WAV files across multiple locations/clusters using a CSV file. CSV must have columns (in order): location_name, location_id, directory_path, date_range, sample_rate, file_count. Auto-creates clusters using date_range as cluster name. Logs progress to file for monitoring. Synchronous/fail-fast execution.",
	}, mcpBulkFileImport)
	mcp.AddTool(server, &mcp.Tool{
		Name:        "import_ml_selections",
		Description: "Import hand sorted ML-detected kiwi call selections from folder structure organized by species/call-type with WAV/PNG pairs",
	}, mcpImportMLSelections)
	// Register schema resources
	schemaResource, schemaTemplate := resources.GetSchemaResources()
	server.AddResource(schemaResource, resources.SchemaResourceHandler)
	server.AddResourceTemplate(schemaTemplate, resources.SchemaResourceHandler)
	// Register prompts
	server.AddPrompt(prompts.GetQueryDatasetsPrompt(), prompts.QueryDatasetsPromptHandler)
	server.AddPrompt(prompts.GetExploreSchemaPrompt(), prompts.ExploreSchemaPromptHandler)
	server.AddPrompt(prompts.GetExploreLocationHierarchyPrompt(), prompts.ExploreLocationHierarchyPromptHandler)
	server.AddPrompt(prompts.GetQueryLocationDataPrompt(), prompts.QueryLocationDataPromptHandler)
	server.AddPrompt(prompts.GetAnalyzeClusterFilesPrompt(), prompts.AnalyzeClusterFilesPromptHandler)
	server.AddPrompt(prompts.GetSystemStatusPrompt(), prompts.SystemStatusPromptHandler)
	// Run the server on stdio transport
	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
		log.Fatalf("Server error: %v", err)
	}
}
// MCP adapter functions — thin wrappers that bridge MCP signatures to core tool functions
func mcpGetCurrentTime(ctx context.Context, req *mcp.CallToolRequest, input tools.GetCurrentTimeInput) (*mcp.CallToolResult, tools.GetCurrentTimeOutput, error) {
	output, err := tools.GetCurrentTime(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpExecuteSQL(ctx context.Context, req *mcp.CallToolRequest, input tools.ExecuteSQLInput) (*mcp.CallToolResult, tools.ExecuteSQLOutput, error) {
	output, err := tools.ExecuteSQL(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpCreateOrUpdateDataset(ctx context.Context, req *mcp.CallToolRequest, input tools.DatasetInput) (*mcp.CallToolResult, tools.DatasetOutput, error) {
	output, err := tools.CreateOrUpdateDataset(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpCreateOrUpdateLocation(ctx context.Context, req *mcp.CallToolRequest, input tools.LocationInput) (*mcp.CallToolResult, tools.LocationOutput, error) {
	output, err := tools.CreateOrUpdateLocation(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpCreateOrUpdateCluster(ctx context.Context, req *mcp.CallToolRequest, input tools.ClusterInput) (*mcp.CallToolResult, tools.ClusterOutput, error) {
	output, err := tools.CreateOrUpdateCluster(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpCreateOrUpdatePattern(ctx context.Context, req *mcp.CallToolRequest, input tools.PatternInput) (*mcp.CallToolResult, tools.PatternOutput, error) {
	output, err := tools.CreateOrUpdatePattern(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpImportFile(ctx context.Context, req *mcp.CallToolRequest, input tools.ImportFileInput) (*mcp.CallToolResult, tools.ImportFileOutput, error) {
	output, err := tools.ImportFile(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpImportAudioFiles(ctx context.Context, req *mcp.CallToolRequest, input tools.ImportAudioFilesInput) (*mcp.CallToolResult, tools.ImportAudioFilesOutput, error) {
	output, err := tools.ImportAudioFiles(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpBulkFileImport(ctx context.Context, req *mcp.CallToolRequest, input tools.BulkFileImportInput) (*mcp.CallToolResult, tools.BulkFileImportOutput, error) {
	output, err := tools.BulkFileImport(ctx, input)
	return &mcp.CallToolResult{}, output, err
}
func mcpImportMLSelections(ctx context.Context, req *mcp.CallToolRequest, input tools.ImportMLSelectionsInput) (*mcp.CallToolResult, tools.ImportMLSelectionsOutput, error) {
	output, err := tools.ImportMLSelections(ctx, input)
	return &mcp.CallToolResult{}, output, err
}

package cmd
import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"skraak/tools"
)
// RunImport handles the "import" subcommand
func RunImport(args []string) {
	if len(args) < 1 {
		printImportUsage()
		os.Exit(1)
	}
	switch args[0] {
	case "bulk":
		runImportBulk(args[1:])
	default:
		fmt.Fprintf(os.Stderr, "Unknown import subcommand: %s\n\n", args[0])
		printImportUsage()
		os.Exit(1)
	}
}
func printImportUsage() {
	fmt.Fprintf(os.Stderr, "Usage: skraak import <subcommand> [options]\n\n")
	fmt.Fprintf(os.Stderr, "Subcommands:\n")
	fmt.Fprintf(os.Stderr, "  bulk    Bulk import WAV files from CSV\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")
	fmt.Fprintf(os.Stderr, "  skraak import bulk --db ./db/skraak.duckdb --dataset abc123 --csv import.csv --log progress.log\n")
}
func runImportBulk(args []string) {
	fs := flag.NewFlagSet("import bulk", flag.ExitOnError)
	dbPath := fs.String("db", "", "Path to DuckDB database (required)")
	datasetID := fs.String("dataset", "", "Dataset ID (required)")
	csvPath := fs.String("csv", "", "Path to CSV file (required)")
	logPath := fs.String("log", "", "Path to progress log file (required)")
	fs.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: skraak import bulk [options]\n\n")
		fmt.Fprintf(os.Stderr, "Bulk import WAV files across multiple locations/clusters using a CSV file.\n\n")
		fmt.Fprintf(os.Stderr, "Options:\n")
		fs.PrintDefaults()
		fmt.Fprintf(os.Stderr, "\nCSV format: location_name,location_id,directory_path,date_range,sample_rate,file_count\n")
		fmt.Fprintf(os.Stderr, "\nMonitor progress: tail -f <log-file>\n")
	}
	if err := fs.Parse(args); err != nil {
		os.Exit(1)
	}
	// Validate required flags
	missing := []string{}
	if *dbPath == "" {
		missing = append(missing, "--db")
	}
	if *datasetID == "" {
		missing = append(missing, "--dataset")
	}
	if *csvPath == "" {
		missing = append(missing, "--csv")
	}
	if *logPath == "" {
		missing = append(missing, "--log")
	}
	if len(missing) > 0 {
		fmt.Fprintf(os.Stderr, "Error: missing required flags: %v\n\n", missing)
		fs.Usage()
		os.Exit(1)
	}
	// Set DB path and run
	tools.SetDBPath(*dbPath)
	input := tools.BulkFileImportInput{
		DatasetID:   *datasetID,
		CSVPath:     *csvPath,
		LogFilePath: *logPath,
	}
	fmt.Fprintf(os.Stderr, "Starting bulk import...\n")
	fmt.Fprintf(os.Stderr, "  Database: %s\n", *dbPath)
	fmt.Fprintf(os.Stderr, "  Dataset:  %s\n", *datasetID)
	fmt.Fprintf(os.Stderr, "  CSV:      %s\n", *csvPath)
	fmt.Fprintf(os.Stderr, "  Log:      %s\n", *logPath)
	fmt.Fprintf(os.Stderr, "\nMonitor progress: tail -f %s\n\n", *logPath)
	output, err := tools.BulkFileImport(context.Background(), input)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		// Still print partial output if available
		if output.TotalLocations > 0 || output.FilesImported > 0 {
			printJSON(output)
		}
		os.Exit(1)
	}
	printJSON(output)
}
func printJSON(v interface{}) {
	enc := json.NewEncoder(os.Stdout)
	enc.SetIndent("", "  ")
	enc.Encode(v)
}

The Skraak MCP Server is a Model Context Protocol (MCP) server **and CLI tool** written in Go that provides a **generic SQL query interface** for an acoustic monitoring system. It follows a two-layer architecture:

The Skraak MCP Server is a Model Context Protocol (MCP) server written in Go that provides a **generic SQL query interface** for an acoustic monitoring system. It follows MCP's three-primitive architecture with an LLM-friendly design:

- **Core logic** (`tools/`): Pure Go functions with no MCP dependency. Input/output via plain structs.
- **MCP adapters** (`cmd/mcp.go`): Thin wrappers bridging MCP types to core functions. Only file importing `mcp` SDK.
- **CLI commands** (`cmd/`): Parse flags, call core functions, print results. Power-user interface.

MCP capabilities:

skraak_mcp/
├── main.go                       # Server entry point, tool registration

skraak/
├── main.go                       # CLI dispatcher (mcp | import | sql)
├── cmd/                          # Command entry points (only MCP importer)
│   ├── mcp.go                    # MCP server setup + adapter wrappers
│   ├── import.go                 # CLI: skraak import bulk ...
│   └── sql.go                    # CLI: skraak sql ...

├── tools/                        # Tool implementations
│   ├── time.go                   # get_current_time (utility tool)
│   ├── sql.go                    # execute_sql (generic query tool)

├── tools/                        # Core logic (NO MCP dependency)
│   ├── time.go                   # get_current_time
│   ├── sql.go                    # execute_sql (generic query)

└── shell_scripts/                # Shell test scripts (end-to-end)

└── shell_scripts/                # Shell test scripts (end-to-end MCP tests)

### Run (stdio mode - waits for MCP protocol input)

### Run MCP Server (stdio mode - waits for MCP protocol input)

### CLI Commands (power-user, no MCP needed)
```bash
# SQL query
./skraak sql --db ./db/skraak.duckdb "SELECT COUNT(*) FROM file WHERE active = true"
./skraak sql --db ./db/skraak.duckdb --limit 10 "SELECT * FROM dataset WHERE active = true"
# Bulk import from CSV
./skraak import bulk --db ./db/skraak.duckdb --dataset abc123 --csv import.csv --log progress.log
```

# CLI sql test (no MCP, direct output)
./skraak sql --db ./db/test.duckdb "SELECT COUNT(*) FROM dataset"

### Latest Update: Bulk File Import Cluster Assignment Bug Fix (2026-02-10)

### Latest Update: CLI Refactoring — Two-Layer Architecture (2026-02-11)
**Major refactoring: Separated core logic from MCP types, added CLI commands**
**Problem:** All tool functions were tightly coupled to MCP SDK types (`*mcp.CallToolRequest`, `*mcp.CallToolResult`). This meant functionality could only be invoked via MCP protocol — no CLI access for power users.
**Solution:** Two-layer architecture separating core logic from MCP adapters.
**Created:**
- `cmd/mcp.go` — MCP server setup + 10 thin adapter wrappers (~3 lines each)
- `cmd/import.go` — `skraak import bulk` CLI command with flag parsing
- `cmd/sql.go` — `skraak sql` CLI command for ad-hoc queries
**Modified (mechanical, all tools/):**
- Removed `*mcp.CallToolRequest` parameter (was never used — `req` always ignored)
- Removed `*mcp.CallToolResult` from returns (was always empty `&mcp.CallToolResult{}`)
- Removed `import "github.com/modelcontextprotocol/go-sdk/mcp"` from all tool files
- Updated test files (`integration_test.go`, `pattern_test.go`) to match new signatures
- Updated `main.go` to pure dispatcher: `mcp | import | sql`
**Architecture:**
```
main.go              → pure dispatcher
cmd/mcp.go           → MCP server + adapter wrappers (ONLY file importing mcp SDK)
cmd/import.go         → CLI: skraak import bulk --db ... --dataset ... --csv ... --log ...
cmd/sql.go            → CLI: skraak sql --db ... "SELECT ..."
tools/*.go            → core logic, NO mcp dependency (plain Go structs in/out)
utils/, db/, etc.     → unchanged
```
**CLI Usage:**
```bash
# MCP server (unchanged)
skraak mcp ./db/skraak.duckdb
# Power-user CLI commands (new)
skraak sql --db ./db/skraak.duckdb "SELECT COUNT(*) FROM file WHERE active = true"
skraak sql --db ./db/skraak.duckdb --limit 10 "SELECT * FROM dataset"
skraak import bulk --db ./db/skraak.duckdb --dataset abc123 --csv import.csv --log progress.log
```

**Benefits:**
- ✅ **CLI access:** Power users can run imports and queries without MCP
- ✅ **Token savings:** CLI commands avoid MCP protocol overhead
- ✅ **Code sharing:** CLI and MCP call identical core functions
- ✅ **MCP SDK contained:** Only `cmd/mcp.go` imports the MCP SDK
- ✅ **Extensible:** New CLI commands just need a file in `cmd/` calling `tools/`
- ✅ **No logic changes:** All core tool logic unchanged, just signature cleanup
- ✅ **All tests pass:** `go test ./...`, all 8 shell test scripts verified
---
### Previous Update: Bulk File Import Cluster Assignment Bug Fix (2026-02-10)

**Last Updated**: 2026-02-10 NZDT
**Status**: Bulk import cluster assignment bug fixed 🐛✅
**Current Tools**: 10 (read: 2, write: 4, import: 4)

**Last Updated**: 2026-02-11 NZDT
**Status**: CLI refactoring complete — two-layer architecture ✅
**Architecture**: `tools/` = core logic (MCP-free), `cmd/mcp.go` = MCP adapters, `cmd/*.go` = CLI commands
**Current Tools**: 10 (read: 2, write: 4, import: 4) — available via both MCP and CLI
**CLI Commands**: `skraak mcp`, `skraak sql`, `skraak import bulk`