feat: local dev flag

.gitignore

···
 platforms
 plugins
 www
+
+*.db

packages/api/internal/config/config.go

···
 	AdminAuthToken       string
 }
 
-func Load() (*Config, error) {
+type LoadOptions struct {
+	Local   bool
+	WorkDir string
+}
+
+func Load(opts LoadOptions) (*Config, error) {
 	loadDotEnv()
 
 	cfg := &Config{
···
 		EnableAdminEndpoints: envBool("ENABLE_ADMIN_ENDPOINTS", false),
 	}
 
+	if opts.Local {
+		dbURL, err := localDatabaseURL(opts.WorkDir)
+		if err != nil {
+			return nil, err
+		}
+		cfg.TursoURL = dbURL
+		cfg.TursoToken = ""
+		cfg.LogFormat = "text"
+	}
+
 	var errs []error
 	if cfg.TursoURL == "" {
 		errs = append(errs, errors.New("TURSO_DATABASE_URL is required"))
···
 		return nil, errors.Join(errs...)
 	}
 	return cfg, nil
+}
+
+func localDatabaseURL(workDir string) (string, error) {
+	if strings.TrimSpace(workDir) == "" {
+		var err error
+		workDir, err = os.Getwd()
+		if err != nil {
+			return "", err
+		}
+	}
+	return "file:" + filepath.Join(workDir, "twister-dev.db"), nil
 }
 
 func loadDotEnv() {

packages/api/internal/config/config_test.go

···
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoadRequiresRemoteTursoConfigurationByDefault(t *testing.T) {
+	t.Setenv("TURSO_DATABASE_URL", "")
+	t.Setenv("TURSO_AUTH_TOKEN", "")
+
+	_, err := Load(LoadOptions{})
+	if err == nil {
+		t.Fatal("expected missing Turso config to fail")
+	}
+}
+
+func TestLoadLocalOverridesRemoteDatabaseAndLogging(t *testing.T) {
+	workDir := t.TempDir()
+	t.Setenv("TURSO_DATABASE_URL", "libsql://example.turso.io")
+	t.Setenv("TURSO_AUTH_TOKEN", "secret")
+	t.Setenv("LOG_FORMAT", "json")
+
+	cfg, err := Load(LoadOptions{Local: true, WorkDir: workDir})
+	if err != nil {
+		t.Fatalf("load config: %v", err)
+	}
+
+	wantURL := "file:" + filepath.Join(workDir, "twister-dev.db")
+	if cfg.TursoURL != wantURL {
+		t.Fatalf("TursoURL: got %q, want %q", cfg.TursoURL, wantURL)
+	}
+	if cfg.TursoToken != "" {
+		t.Fatalf("TursoToken: got %q, want empty", cfg.TursoToken)
+	}
+	if cfg.LogFormat != "text" {
+		t.Fatalf("LogFormat: got %q, want %q", cfg.LogFormat, "text")
+	}
+}
+
+func TestLoadLocalUsesCurrentWorkingDirectoryWhenUnset(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("getwd: %v", err)
+	}
+	t.Setenv("TURSO_DATABASE_URL", "")
+	t.Setenv("TURSO_AUTH_TOKEN", "")
+
+	cfg, err := Load(LoadOptions{Local: true})
+	if err != nil {
+		t.Fatalf("load config: %v", err)
+	}
+
+	wantURL := "file:" + filepath.Join(wd, "twister-dev.db")
+	if cfg.TursoURL != wantURL {
+		t.Fatalf("TursoURL: got %q, want %q", cfg.TursoURL, wantURL)
+	}
+}

packages/api/main.go

···
 )
 
 func main() {
+	var local bool
+
 	root := &cobra.Command{
 		Use:           "twister",
 		Short:         "Tangled search service",
···
 		SilenceErrors: true,
 	}
 
+	root.PersistentFlags().BoolVar(&local, "local", false, "Use a local twister-dev.db database and text logs for development")
+
 	root.AddCommand(
-		newAPICmd(),
-		newIndexerCmd(),
-		newBackfillCmd(),
-		newEmbedWorkerCmd(),
-		newReindexCmd(),
-		newReembedCmd(),
-		newHealthcheckCmd(),
+		newAPICmd(&local),
+		newIndexerCmd(&local),
+		newBackfillCmd(&local),
+		newEmbedWorkerCmd(&local),
+		newReindexCmd(&local),
+		newReembedCmd(&local),
+		newHealthcheckCmd(&local),
 	)
 
 	if err := root.Execute(); err != nil {
···
 	return ctx, cancel
 }
 
-func newAPICmd() *cobra.Command {
+func newAPICmd(local *bool) *cobra.Command {
 	return &cobra.Command{
 		Use:     "api",
 		Aliases: []string{"serve"},
 		Short:   "Start the HTTP search API",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}
···
 	}
 }
 
-func newIndexerCmd() *cobra.Command {
+func newIndexerCmd(local *bool) *cobra.Command {
 	return &cobra.Command{
 		Use:   "indexer",
 		Short: "Start the Tap consumer and indexer",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}
···
 	}
 }
 
-func newEmbedWorkerCmd() *cobra.Command {
+func newEmbedWorkerCmd(local *bool) *cobra.Command {
 	return &cobra.Command{
 		Use:   "embed-worker",
 		Short: "Start the async embedding worker",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}
···
 	}
 }
 
-func newBackfillCmd() *cobra.Command {
+func newBackfillCmd(local *bool) *cobra.Command {
 	var opts backfill.Options
 
 	cmd := &cobra.Command{
 		Use:   "backfill",
 		Short: "Discover users from seeds and register repos for Tap backfill",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}
···
 	return cmd
 }
 
-func newReindexCmd() *cobra.Command {
+func newReindexCmd(local *bool) *cobra.Command {
 	return &cobra.Command{
 		Use:   "reindex",
 		Short: "Re-normalize and upsert all documents",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}
···
 	}
 }
 
-func newReembedCmd() *cobra.Command {
+func newReembedCmd(local *bool) *cobra.Command {
 	return &cobra.Command{
 		Use:   "reembed",
 		Short: "Re-generate all embeddings",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}
···
 	}
 }
 
-func newHealthcheckCmd() *cobra.Command {
+func newHealthcheckCmd(local *bool) *cobra.Command {
 	return &cobra.Command{
 		Use:   "healthcheck",
 		Short: "One-shot health probe",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := config.Load()
+			cfg, err := config.Load(config.LoadOptions{Local: *local})
 			if err != nil {
 				return fmt.Errorf("config: %w", err)
 			}