✨ Added the backup feature

internal/services/backup_service.go

@@ -0,0 +1,388 @@
+package services
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/go-git/go-git/v5"
+	gitConfig "github.com/go-git/go-git/v5/config"
+	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5/plumbing/transport"
+	"github.com/go-git/go-git/v5/plumbing/transport/http"
+	"github.com/go-git/go-git/v5/plumbing/transport/ssh"
+	"github.com/wailsapp/wails/v3/pkg/services/log"
+
+	"voidraft/internal/models"
+
+	_ "modernc.org/sqlite"
+)
+
+const (
+	dbSerializeFile = "voidraft_data.bin"
+)
+
+// BackupService 提供基于Git的备份功能
+type BackupService struct {
+	configService    *ConfigService
+	dbService        *DatabaseService
+	repository       *git.Repository
+	logger           *log.Service
+	isInitialized    bool
+	autoBackupTicker *time.Ticker
+	autoBackupStop   chan bool
+}
+
+// NewBackupService 创建新的备份服务实例
+func NewBackupService(configService *ConfigService, dbService *DatabaseService, logger *log.Service) *BackupService {
+	return &BackupService{
+		configService: configService,
+		dbService:     dbService,
+		logger:        logger,
+	}
+}
+
+// Initialize 初始化备份服务
+func (s *BackupService) Initialize() error {
+	config, repoPath, err := s.getConfigAndPath()
+	if err != nil {
+		return fmt.Errorf("getting backup config: %w", err)
+	}
+
+	if !config.Enabled {
+		return nil
+	}
+
+	// 初始化仓库
+	if err := s.initializeRepository(config, repoPath); err != nil {
+		return fmt.Errorf("initializing repository: %w", err)
+	}
+
+	// 启动自动备份
+	if config.AutoBackup && config.BackupInterval > 0 {
+		s.StartAutoBackup()
+	}
+
+	s.isInitialized = true
+	return nil
+}
+
+// getConfigAndPath 获取备份配置和仓库路径
+func (s *BackupService) getConfigAndPath() (*models.GitBackupConfig, string, error) {
+	appConfig, err := s.configService.GetConfig()
+	if err != nil {
+		return nil, "", fmt.Errorf("getting app config: %w", err)
+	}
+	return &appConfig.Backup, appConfig.General.DataPath, nil
+}
+
+// initializeRepository 初始化或打开Git仓库并设置远程
+func (s *BackupService) initializeRepository(config *models.GitBackupConfig, repoPath string) error {
+
+	// 检查本地仓库是否存在
+	_, err := os.Stat(filepath.Join(repoPath, ".git"))
+	if os.IsNotExist(err) {
+		// 仓库不存在，初始化新仓库
+		repo, err := git.PlainInit(repoPath, false)
+		if err != nil {
+			return fmt.Errorf("error initializing repository: %w", err)
+		}
+		s.repository = repo
+	} else if err != nil {
+		return fmt.Errorf("error checking repository path: %w", err)
+	} else {
+		// 仓库已存在，打开现有仓库
+		repo, err := git.PlainOpen(repoPath)
+		if err != nil {
+			return fmt.Errorf("error opening local repository: %w", err)
+		}
+		s.repository = repo
+	}
+
+	// 设置或更新远程仓库
+	remote, err := s.repository.Remote("origin")
+	if err != nil {
+		if errors.Is(err, git.ErrRemoteNotFound) {
+			// 远程不存在，添加远程
+			_, err = s.repository.CreateRemote(&gitConfig.RemoteConfig{
+				Name: "origin",
+				URLs: []string{config.RepoURL},
+			})
+			if err != nil {
+				return fmt.Errorf("error creating remote: %w", err)
+			}
+		} else {
+			return fmt.Errorf("error getting remote: %w", err)
+		}
+	} else {
+		// 检查远程URL是否一致，如果不一致则更新
+		if len(remote.Config().URLs) > 0 && remote.Config().URLs[0] != config.RepoURL {
+			if err := s.repository.DeleteRemote("origin"); err != nil {
+				return fmt.Errorf("error deleting remote: %w", err)
+			}
+			_, err = s.repository.CreateRemote(&gitConfig.RemoteConfig{
+				Name: "origin",
+				URLs: []string{config.RepoURL},
+			})
+			if err != nil {
+				return fmt.Errorf("error creating new remote: %w", err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// getAuthMethod 根据配置获取认证方法
+func (s *BackupService) getAuthMethod(config *models.GitBackupConfig) (transport.AuthMethod, error) {
+	switch config.AuthMethod {
+	case models.Token:
+		if config.Token == "" {
+			return nil, errors.New("token authentication requires a valid token")
+		}
+		return &http.BasicAuth{
+			Username: "git", // 使用token时，用户名可以是任意值
+			Password: config.Token,
+		}, nil
+
+	case models.UserPass:
+		if config.Username == "" || config.Password == "" {
+			return nil, errors.New("username/password authentication requires both username and password")
+		}
+		return &http.BasicAuth{
+			Username: config.Username,
+			Password: config.Password,
+		}, nil
+
+	case models.SSHKey:
+		if config.SSHKeyPath == "" {
+			return nil, errors.New("SSH key authentication requires a valid SSH key path")
+		}
+		publicKeys, err := ssh.NewPublicKeysFromFile("git", config.SSHKeyPath, config.SSHKeyPass)
+		if err != nil {
+			return nil, fmt.Errorf("error creating SSH public keys: %w", err)
+		}
+		return publicKeys, nil
+
+	default:
+		return nil, fmt.Errorf("unsupported authentication method: %s", config.AuthMethod)
+	}
+}
+
+// serializeDatabase 序列化数据库到文件
+func (s *BackupService) serializeDatabase(repoPath string) error {
+	if s.dbService == nil || s.dbService.db == nil {
+		return errors.New("database service not available")
+	}
+
+	// 获取数据库路径
+	dbPath, err := s.dbService.getDatabasePath()
+	if err != nil {
+		return fmt.Errorf("getting database path: %w", err)
+	}
+
+	// 关闭数据库连接以确保所有更改都写入磁盘
+	if err := s.dbService.ServiceShutdown(); err != nil {
+		s.logger.Error("Failed to close database connection", "error", err)
+	}
+
+	// 直接复制数据库文件到序列化文件
+	dbData, err := os.ReadFile(dbPath)
+	if err != nil {
+		return fmt.Errorf("reading database file: %w", err)
+	}
+
+	binFilePath := filepath.Join(repoPath, dbSerializeFile)
+	if err := os.WriteFile(binFilePath, dbData, 0644); err != nil {
+		return fmt.Errorf("writing serialized database to file: %w", err)
+	}
+
+	// 重新初始化数据库服务
+	if err := s.dbService.initDatabase(); err != nil {
+		return fmt.Errorf("reinitializing database: %w", err)
+	}
+
+	return nil
+}
+
+// PushToRemote 推送本地更改到远程仓库
+func (s *BackupService) PushToRemote() error {
+	if !s.isInitialized {
+		return errors.New("backup service not initialized")
+	}
+
+	config, repoPath, err := s.getConfigAndPath()
+	if err != nil {
+		return fmt.Errorf("getting backup config: %w", err)
+	}
+
+	if !config.Enabled {
+		return errors.New("backup is disabled")
+	}
+
+	// 数据库序列化文件的路径
+	binFilePath := filepath.Join(repoPath, dbSerializeFile)
+
+	// 函数返回前都删除临时文件
+	defer func() {
+		if _, err := os.Stat(binFilePath); err == nil {
+			os.Remove(binFilePath)
+		}
+	}()
+
+	// 序列化数据库
+	if err := s.serializeDatabase(repoPath); err != nil {
+		return fmt.Errorf("serializing database: %w", err)
+	}
+
+	// 获取工作树
+	w, err := s.repository.Worktree()
+	if err != nil {
+		return fmt.Errorf("getting worktree: %w", err)
+	}
+
+	// 添加序列化的数据库文件
+	if _, err := w.Add(dbSerializeFile); err != nil {
+		return fmt.Errorf("adding serialized database file: %w", err)
+	}
+
+	// 检查是否有变化需要提交
+	status, err := w.Status()
+	if err != nil {
+		return fmt.Errorf("getting worktree status: %w", err)
+	}
+
+	// 如果没有变化，直接返回
+	if status.IsClean() {
+		return errors.New("no changes to backup")
+	}
+
+	// 创建提交
+	_, err = w.Commit(fmt.Sprintf("Backup %s", time.Now().Format("2006-01-02 15:04:05")), &git.CommitOptions{
+		Author: &object.Signature{
+			Name:  "VoidRaft",
+			Email: "backup@voidraft.app",
+			When:  time.Now(),
+		},
+	})
+	if err != nil {
+		if strings.Contains(err.Error(), "cannot create empty commit") {
+			return errors.New("no changes to backup")
+		}
+		return fmt.Errorf("creating commit: %w", err)
+	}
+
+	// 获取认证方法并推送到远程
+	auth, err := s.getAuthMethod(config)
+	if err != nil {
+		return fmt.Errorf("getting auth method: %w", err)
+	}
+
+	// 推送到远程仓库
+	if err := s.repository.Push(&git.PushOptions{
+		RemoteName: "origin",
+		Auth:       auth,
+	}); err != nil && !errors.Is(err, git.NoErrAlreadyUpToDate) {
+		// 忽略一些常见的非错误情况
+		if strings.Contains(err.Error(), "clean working tree") ||
+			strings.Contains(err.Error(), "already up-to-date") ||
+			strings.Contains(err.Error(), " clean working tree") ||
+			strings.Contains(err.Error(), "reference not found") {
+			// 更新最后推送时间
+			return errors.New("no changes to backup")
+		}
+		return fmt.Errorf("push failed: %w", err)
+	}
+
+	return nil
+}
+
+// StartAutoBackup 启动自动备份定时器
+func (s *BackupService) StartAutoBackup() error {
+	config, _, err := s.getConfigAndPath()
+	if err != nil {
+		return fmt.Errorf("getting backup config: %w", err)
+	}
+
+	if !config.AutoBackup || config.BackupInterval <= 0 {
+		return nil
+	}
+
+	s.StopAutoBackup()
+
+	// 将秒转换为分钟
+	s.autoBackupTicker = time.NewTicker(time.Duration(config.BackupInterval) * time.Minute)
+	s.autoBackupStop = make(chan bool)
+
+	go func() {
+		for {
+			select {
+			case <-s.autoBackupTicker.C:
+				// 执行推送操作
+				if err := s.PushToRemote(); err != nil {
+					s.logger.Error("Auto backup failed", "error", err)
+				}
+			case <-s.autoBackupStop:
+				return
+			}
+		}
+	}()
+
+	return nil
+}
+
+// StopAutoBackup 停止自动备份
+func (s *BackupService) StopAutoBackup() {
+	if s.autoBackupTicker != nil {
+		s.autoBackupTicker.Stop()
+		s.autoBackupTicker = nil
+	}
+
+	if s.autoBackupStop != nil {
+		close(s.autoBackupStop)
+		s.autoBackupStop = nil
+	}
+}
+
+// Reinitialize 重新初始化备份服务，用于响应配置变更
+func (s *BackupService) Reinitialize() error {
+	// 停止自动备份
+	s.StopAutoBackup()
+
+	// 重新设置标志
+	s.isInitialized = false
+
+	// 重新初始化
+	return s.Initialize()
+}
+
+// HandleConfigChange 处理备份配置变更
+func (s *BackupService) HandleConfigChange(config *models.GitBackupConfig) error {
+
+	// 如果备份功能禁用，只需停止自动备份
+	if !config.Enabled {
+		s.StopAutoBackup()
+		s.isInitialized = false
+		return nil
+	}
+
+	// 如果服务已初始化，重新初始化以应用新配置
+	if s.isInitialized {
+		return s.Reinitialize()
+	}
+
+	// 如果服务未初始化但已启用，则初始化
+	if config.Enabled && !s.isInitialized {
+		return s.Initialize()
+	}
+
+	return nil
+}
+
+// ServiceShutdown 服务关闭时的清理工作
+func (s *BackupService) ServiceShutdown() {
+	s.StopAutoBackup()
+}

internal/services/config_migration_service.go

@@ -19,7 +19,7 @@ import (
 
 const (
 	// CurrentAppConfigVersion 当前应用配置版本
-	CurrentAppConfigVersion = "1.2.0"
+	CurrentAppConfigVersion = "1.3.0"
 	// BackupFilePattern 备份文件名模式
 	BackupFilePattern = "%s.backup.%s.json"
 

internal/services/config_notification_service.go

@@ -22,6 +22,8 @@ const (
 	ConfigChangeTypeHotkey ConfigChangeType = "hotkey"
 	// ConfigChangeTypeDataPath 数据路径配置变更
 	ConfigChangeTypeDataPath ConfigChangeType = "datapath"
+	// ConfigChangeTypeBackup 备份配置变更
+	ConfigChangeTypeBackup ConfigChangeType = "backup"
 )
 
 // ConfigChangeCallback 配置变更回调函数类型
@@ -445,6 +447,29 @@ func CreateDataPathListener(name string, callback func() error) *ConfigListener
 	}
 }
 
+// CreateBackupConfigListener 创建备份配置监听器
+func CreateBackupConfigListener(name string, callback func(config *models.GitBackupConfig) error) *ConfigListener {
+	return &ConfigListener{
+		Name:       name,
+		ChangeType: ConfigChangeTypeBackup,
+		Callback: func(changeType ConfigChangeType, oldConfig, newConfig *models.AppConfig) error {
+			if newConfig == nil {
+				defaultConfig := models.NewDefaultAppConfig()
+				return callback(&defaultConfig.Backup)
+			}
+			return callback(&newConfig.Backup)
+		},
+		DebounceDelay: 200 * time.Millisecond,
+		GetConfigFunc: func(k *koanf.Koanf) *models.AppConfig {
+			var config models.AppConfig
+			if err := k.Unmarshal("", &config); err != nil {
+				return nil
+			}
+			return &config
+		},
+	}
+}
+
 // ServiceShutdown 关闭服务
 func (cns *ConfigNotificationService) ServiceShutdown() error {
 	cns.Cleanup()

internal/services/config_service.go

@@ -298,6 +298,16 @@ func (cs *ConfigService) SetDataPathChangeCallback(callback func() error) error
 	return cs.notificationService.RegisterListener(dataPathListener)
 }
 
+// SetBackupConfigChangeCallback 设置备份配置变更回调
+func (cs *ConfigService) SetBackupConfigChangeCallback(callback func(config *models.GitBackupConfig) error) error {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+
+	// 创建备份配置监听器并注册
+	backupListener := CreateBackupConfigListener("DefaultBackupConfigListener", callback)
+	return cs.notificationService.RegisterListener(backupListener)
+}
+
 // ServiceShutdown 关闭服务
 func (cs *ConfigService) ServiceShutdown() error {
 	cs.stopWatching()

internal/services/database_service.go

@@ -2,18 +2,18 @@ package services
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"os"
 	"path/filepath"
 	"reflect"
-	"strings"
 	"sync"
 	"time"
 	"voidraft/internal/models"
 
 	"github.com/wailsapp/wails/v3/pkg/application"
 	"github.com/wailsapp/wails/v3/pkg/services/log"
-	"github.com/wailsapp/wails/v3/pkg/services/sqlite"
+	_ "modernc.org/sqlite"
 )
 
 const (
@@ -63,20 +63,6 @@ CREATE TABLE IF NOT EXISTS key_bindings (
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     UNIQUE(command, extension)
 )`
-
-	// Git sync logs table
-	sqlCreateSyncLogsTable = `
-CREATE TABLE IF NOT EXISTS sync_logs (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-    action TEXT NOT NULL, 
-    status TEXT NOT NULL,
-    message TEXT,
-    commit_id TEXT,
-    changed_files INTEGER DEFAULT 0,
-    repo_url TEXT NOT NULL,
-    branch TEXT NOT NULL
-)`
 )
 
 // ColumnInfo 存储列的信息
@@ -95,7 +81,7 @@ type TableModel struct {
 type DatabaseService struct {
 	configService *ConfigService
 	logger        *log.Service
-	SQLite        *sqlite.Service
+	db            *sql.DB
 	mu            sync.RWMutex
 	ctx           context.Context
 	tableModels   []TableModel // 注册的表模型
@@ -110,7 +96,6 @@ func NewDatabaseService(configService *ConfigService, logger *log.Service) *Data
 	ds := &DatabaseService{
 		configService: configService,
 		logger:        logger,
-		SQLite:        sqlite.New(),
 	}
 
 	// 注册所有模型
@@ -127,8 +112,6 @@ func (ds *DatabaseService) registerAllModels() {
 	ds.RegisterModel("extensions", &models.Extension{})
 	// 快捷键表
 	ds.RegisterModel("key_bindings", &models.KeyBinding{})
-	// 同步日志表
-	ds.RegisterModel("sync_logs", &models.SyncLogEntry{})
 }
 
 // ServiceStartup initializes the service when the application starts
@@ -150,28 +133,19 @@ func (ds *DatabaseService) initDatabase() error {
 		return fmt.Errorf("failed to create database directory: %w", err)
 	}
 
-	// 检查数据库文件是否存在，如果不存在则创建
-	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
-		// 创建空文件
-		file, err := os.Create(dbPath)
-		if err != nil {
-			return fmt.Errorf("failed to create database file: %w", err)
-		}
-		file.Close()
-	}
-
-	// 配置SQLite服务
-	ds.SQLite.Configure(&sqlite.Config{
-		DBSource: dbPath,
-	})
-
 	// 打开数据库连接
-	if err := ds.SQLite.Open(); err != nil {
+	ds.db, err = sql.Open("sqlite", dbPath)
+	if err != nil {
 		return fmt.Errorf("failed to open database: %w", err)
 	}
 
+	// 测试连接
+	if err := ds.db.Ping(); err != nil {
+		return fmt.Errorf("failed to ping database: %w", err)
+	}
+
 	// 应用性能优化设置
-	if err := ds.SQLite.Execute(sqlOptimizationSettings); err != nil {
+	if _, err := ds.db.Exec(sqlOptimizationSettings); err != nil {
 		return fmt.Errorf("failed to apply optimization settings: %w", err)
 	}
 
@@ -207,11 +181,10 @@ func (ds *DatabaseService) createTables() error {
 		sqlCreateDocumentsTable,
 		sqlCreateExtensionsTable,
 		sqlCreateKeyBindingsTable,
-		sqlCreateSyncLogsTable,
 	}
 
 	for _, table := range tables {
-		if err := ds.SQLite.Execute(table); err != nil {
+		if _, err := ds.db.Exec(table); err != nil {
 			return err
 		}
 	}
@@ -231,14 +204,10 @@ func (ds *DatabaseService) createIndexes() error {
 		`CREATE INDEX IF NOT EXISTS idx_key_bindings_command ON key_bindings(command)`,
 		`CREATE INDEX IF NOT EXISTS idx_key_bindings_extension ON key_bindings(extension)`,
 		`CREATE INDEX IF NOT EXISTS idx_key_bindings_enabled ON key_bindings(enabled)`,
-		// Sync logs indexes
-		`CREATE INDEX IF NOT EXISTS idx_sync_logs_timestamp ON sync_logs(timestamp DESC)`,
-		`CREATE INDEX IF NOT EXISTS idx_sync_logs_action ON sync_logs(action)`,
-		`CREATE INDEX IF NOT EXISTS idx_sync_logs_status ON sync_logs(status)`,
 	}
 
 	for _, index := range indexes {
-		if err := ds.SQLite.Execute(index); err != nil {
+		if _, err := ds.db.Exec(index); err != nil {
 			return err
 		}
 	}
@@ -286,7 +255,7 @@ func (ds *DatabaseService) syncModelTable(tableName string, model interface{}) e
 			// 执行添加列的SQL
 			alterSQL := fmt.Sprintf("ALTER TABLE %s ADD COLUMN %s %s DEFAULT %s",
 				tableName, colName, colInfo.SQLType, colInfo.DefaultValue)
-			if err := ds.SQLite.Execute(alterSQL); err != nil {
+			if _, err := ds.db.Exec(alterSQL); err != nil {
 				return fmt.Errorf("failed to add column %s: %w", colName, err)
 			}
 		}
@@ -298,23 +267,30 @@ func (ds *DatabaseService) syncModelTable(tableName string, model interface{}) e
 // getTableColumns 获取表的列信息
 func (ds *DatabaseService) getTableColumns(table string) (map[string]string, error) {
 	query := fmt.Sprintf("PRAGMA table_info(%s)", table)
-	rows, err := ds.SQLite.Query(query)
+	rows, err := ds.db.Query(query)
 	if err != nil {
 		return nil, err
 	}
+	defer rows.Close()
 
 	columns := make(map[string]string)
-	for _, row := range rows {
-		name, ok1 := row["name"].(string)
-		typeName, ok2 := row["type"].(string)
+	for rows.Next() {
+		var cid int
+		var name, typeName string
+		var notNull, pk int
+		var dflt_value interface{}
 
-		if !ok1 || !ok2 {
-			continue
+		if err := rows.Scan(&cid, &name, &typeName, &notNull, &dflt_value, &pk); err != nil {
+			return nil, err
 		}
 
 		columns[name] = typeName
 	}
 
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
 	return columns, nil
 }
 
@@ -336,11 +312,11 @@ func (ds *DatabaseService) getModelColumns(model interface{}) (map[string]Column
 	for i := 0; i < t.NumField(); i++ {
 		field := t.Field(i)
 
-		// 获取数据库字段名
+		// 只处理有db标签的字段
 		dbTag := field.Tag.Get("db")
 		if dbTag == "" {
-			// 如果没有db标签，则使用字段名的蛇形命名方式
-			dbTag = toSnakeCase(field.Name)
+			// 如果没有db标签，跳过该字段
+			continue
 		}
 
 		// 获取字段类型对应的SQL类型和默认值
@@ -355,18 +331,6 @@ func (ds *DatabaseService) getModelColumns(model interface{}) (map[string]Column
 	return columns, nil
 }
 
-// toSnakeCase 将驼峰命名转换为蛇形命名
-func toSnakeCase(s string) string {
-	var result strings.Builder
-	for i, r := range s {
-		if i > 0 && 'A' <= r && r <= 'Z' {
-			result.WriteRune('_')
-		}
-		result.WriteRune(r)
-	}
-	return strings.ToLower(result.String())
-}
-
 // getSQLTypeAndDefault 根据Go类型获取对应的SQL类型和默认值
 func getSQLTypeAndDefault(t reflect.Type) (string, string) {
 	switch t.Kind() {
@@ -390,14 +354,19 @@ func getSQLTypeAndDefault(t reflect.Type) (string, string) {
 
 // ServiceShutdown shuts down the service when the application closes
 func (ds *DatabaseService) ServiceShutdown() error {
-	return ds.SQLite.Close()
+	if ds.db != nil {
+		return ds.db.Close()
+	}
+	return nil
 }
 
 // OnDataPathChanged handles data path changes
 func (ds *DatabaseService) OnDataPathChanged() error {
 	// 关闭当前连接
-	if err := ds.SQLite.Close(); err != nil {
-		return err
+	if ds.db != nil {
+		if err := ds.db.Close(); err != nil {
+			return err
+		}
 	}
 
 	// 用新路径重新初始化

internal/services/dialog_service.go

@@ -50,7 +50,6 @@ func (ds *DialogService) SelectDirectory() (string, error) {
 
 		// 对话框文本配置
 		Title:      "Select Directory",
-		Message:    "Select the folder where you want to store your app data",
 		ButtonText: "Select",
 
 		// 不设置过滤器，因为我们选择目录
@@ -69,3 +68,44 @@ func (ds *DialogService) SelectDirectory() (string, error) {
 	}
 	return path, nil
 }
+
+// SelectFile 打开文件选择对话框
+func (ds *DialogService) SelectFile() (string, error) {
+	dialog := application.OpenFileDialog()
+	dialog.SetOptions(&application.OpenFileDialogOptions{
+		// 目录选择配置
+		CanChooseDirectories:    false, // 允许选择目录
+		CanChooseFiles:          true,  // 不允许选择文件
+		CanCreateDirectories:    true,  // 允许创建新目录
+		AllowsMultipleSelection: false, // 单选模式
+
+		// 显示配置
+		ShowHiddenFiles:                 true,  // 不显示隐藏文件
+		HideExtension:                   false, // 不隐藏扩展名
+		CanSelectHiddenExtension:        false, // 不允许选择隐藏扩展名
+		TreatsFilePackagesAsDirectories: false, // 不将文件包当作目录处理
+		AllowsOtherFileTypes:            false, // 不允许其他文件类型
+
+		// 系统配置
+		ResolvesAliases: true, // 解析别名/快捷方式
+
+		// 对话框文本配置
+		Title:      "Select File",
+		ButtonText: "Select File",
+
+		// 不设置过滤器，因为我们选择目录
+		Filters: nil,
+
+		// 不指定默认目录，让系统决定
+		Directory: "",
+
+		// 绑定到主窗口
+		Window: ds.window,
+	})
+
+	path, err := dialog.PromptForSingleSelection()
+	if err != nil {
+		return "", err
+	}
+	return path, nil
+}

internal/services/document_service.go

@@ -111,19 +111,15 @@ func (ds *DocumentService) ServiceStartup(ctx context.Context, options applicati
 
 // ensureDefaultDocument ensures a default document exists
 func (ds *DocumentService) ensureDefaultDocument() error {
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
 	// Check if any document exists
-	rows, err := ds.databaseService.SQLite.Query(sqlCountDocuments)
+	var count int64
+	err := ds.databaseService.db.QueryRow(sqlCountDocuments).Scan(&count)
 	if err != nil {
-		return err
-	}
-
-	if len(rows) == 0 {
-		return fmt.Errorf("failed to query document count")
-	}
-
-	count, ok := rows[0]["COUNT(*)"].(int64)
-	if !ok {
-		return fmt.Errorf("failed to convert count to int64")
+		return fmt.Errorf("failed to query document count: %w", err)
 	}
 
 	// If no documents exist, create default document
@@ -140,52 +136,42 @@ func (ds *DocumentService) GetDocumentByID(id int64) (*models.Document, error) {
 	ds.mu.RLock()
 	defer ds.mu.RUnlock()
 
-	rows, err := ds.databaseService.SQLite.Query(sqlGetDocumentByID, id)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return nil, errors.New("database service not available")
+	}
+
+	doc := &models.Document{}
+	var createdAt, updatedAt string
+	var isDeleted, isLocked int
+
+	err := ds.databaseService.db.QueryRow(sqlGetDocumentByID, id).Scan(
+		&doc.ID,
+		&doc.Title,
+		&doc.Content,
+		&createdAt,
+		&updatedAt,
+		&isDeleted,
+		&isLocked,
+	)
+
 	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, nil
+		}
 		return nil, fmt.Errorf("failed to get document by ID: %w", err)
 	}
 
-	if len(rows) == 0 {
-		return nil, nil
+	// 转换时间字段
+	if t, err := time.Parse("2006-01-02 15:04:05", createdAt); err == nil {
+		doc.CreatedAt = t
+	}
+	if t, err := time.Parse("2006-01-02 15:04:05", updatedAt); err == nil {
+		doc.UpdatedAt = t
 	}
 
-	row := rows[0]
-	doc := &models.Document{}
-
-	// 从Row中提取数据
-	if idVal, ok := row["id"].(int64); ok {
-		doc.ID = idVal
-	}
-
-	if title, ok := row["title"].(string); ok {
-		doc.Title = title
-	}
-
-	if content, ok := row["content"].(string); ok {
-		doc.Content = content
-	}
-
-	if createdAt, ok := row["created_at"].(string); ok {
-		t, err := time.Parse("2006-01-02 15:04:05", createdAt)
-		if err == nil {
-			doc.CreatedAt = t
-		}
-	}
-
-	if updatedAt, ok := row["updated_at"].(string); ok {
-		t, err := time.Parse("2006-01-02 15:04:05", updatedAt)
-		if err == nil {
-			doc.UpdatedAt = t
-		}
-	}
-
-	if isDeletedInt, ok := row["is_deleted"].(int64); ok {
-		doc.IsDeleted = isDeletedInt == 1
-	}
-
-	if isLockedInt, ok := row["is_locked"].(int64); ok {
-		doc.IsLocked = isLockedInt == 1
-	}
+	// 转换布尔字段
+	doc.IsDeleted = isDeleted == 1
+	doc.IsLocked = isLocked == 1
 
 	return doc, nil
 }
@@ -195,6 +181,10 @@ func (ds *DocumentService) CreateDocument(title string) (*models.Document, error
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return nil, errors.New("database service not available")
+	}
+
 	// Create document with default content
 	now := time.Now()
 	doc := &models.Document{
@@ -207,27 +197,18 @@ func (ds *DocumentService) CreateDocument(title string) (*models.Document, error
 	}
 
 	// 执行插入操作
-	if err := ds.databaseService.SQLite.Execute(sqlInsertDocument,
-		doc.Title, doc.Content, doc.CreatedAt, doc.UpdatedAt); err != nil {
+	result, err := ds.databaseService.db.Exec(sqlInsertDocument,
+		doc.Title, doc.Content, doc.CreatedAt.Format("2006-01-02 15:04:05"), doc.UpdatedAt.Format("2006-01-02 15:04:05"))
+	if err != nil {
 		return nil, fmt.Errorf("failed to create document: %w", err)
 	}
 
 	// 获取自增ID
-	lastIDRows, err := ds.databaseService.SQLite.Query("SELECT last_insert_rowid()")
+	lastID, err := result.LastInsertId()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get last insert ID: %w", err)
 	}
 
-	if len(lastIDRows) == 0 {
-		return nil, fmt.Errorf("no rows returned for last insert ID query")
-	}
-
-	// 从结果中提取ID
-	lastID, ok := lastIDRows[0]["last_insert_rowid()"].(int64)
-	if !ok {
-		return nil, fmt.Errorf("failed to convert last insert ID to int64")
-	}
-
 	// 返回带ID的文档
 	doc.ID = lastID
 	return doc, nil
@@ -238,6 +219,10 @@ func (ds *DocumentService) LockDocument(id int64) error {
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
 	// 检查文档是否存在且未删除
 	doc, err := ds.GetDocumentByID(id)
 	if err != nil {
@@ -255,7 +240,7 @@ func (ds *DocumentService) LockDocument(id int64) error {
 		return nil
 	}
 
-	err = ds.databaseService.SQLite.Execute(sqlSetDocumentLocked, time.Now(), id)
+	_, err = ds.databaseService.db.Exec(sqlSetDocumentLocked, time.Now().Format("2006-01-02 15:04:05"), id)
 	if err != nil {
 		return fmt.Errorf("failed to lock document: %w", err)
 	}
@@ -267,6 +252,10 @@ func (ds *DocumentService) UnlockDocument(id int64) error {
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
 	// 检查文档是否存在
 	doc, err := ds.GetDocumentByID(id)
 	if err != nil {
@@ -281,7 +270,7 @@ func (ds *DocumentService) UnlockDocument(id int64) error {
 		return nil
 	}
 
-	err = ds.databaseService.SQLite.Execute(sqlSetDocumentUnlocked, time.Now(), id)
+	_, err = ds.databaseService.db.Exec(sqlSetDocumentUnlocked, time.Now().Format("2006-01-02 15:04:05"), id)
 	if err != nil {
 		return fmt.Errorf("failed to unlock document: %w", err)
 	}
@@ -293,7 +282,11 @@ func (ds *DocumentService) UpdateDocumentContent(id int64, content string) error
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
-	err := ds.databaseService.SQLite.Execute(sqlUpdateDocumentContent, content, time.Now(), id)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
+	_, err := ds.databaseService.db.Exec(sqlUpdateDocumentContent, content, time.Now().Format("2006-01-02 15:04:05"), id)
 	if err != nil {
 		return fmt.Errorf("failed to update document content: %w", err)
 	}
@@ -305,7 +298,11 @@ func (ds *DocumentService) UpdateDocumentTitle(id int64, title string) error {
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
-	err := ds.databaseService.SQLite.Execute(sqlUpdateDocumentTitle, title, time.Now(), id)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
+	_, err := ds.databaseService.db.Exec(sqlUpdateDocumentTitle, title, time.Now().Format("2006-01-02 15:04:05"), id)
 	if err != nil {
 		return fmt.Errorf("failed to update document title: %w", err)
 	}
@@ -317,6 +314,10 @@ func (ds *DocumentService) DeleteDocument(id int64) error {
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
 	// 不允许删除默认文档
 	if id == sqlDefaultDocumentID {
 		return fmt.Errorf("cannot delete the default document")
@@ -334,7 +335,7 @@ func (ds *DocumentService) DeleteDocument(id int64) error {
 		return fmt.Errorf("cannot delete locked document: %d", id)
 	}
 
-	err = ds.databaseService.SQLite.Execute(sqlMarkDocumentAsDeleted, time.Now(), id)
+	_, err = ds.databaseService.db.Exec(sqlMarkDocumentAsDeleted, time.Now().Format("2006-01-02 15:04:05"), id)
 	if err != nil {
 		return fmt.Errorf("failed to mark document as deleted: %w", err)
 	}
@@ -346,7 +347,11 @@ func (ds *DocumentService) RestoreDocument(id int64) error {
 	ds.mu.Lock()
 	defer ds.mu.Unlock()
 
-	err := ds.databaseService.SQLite.Execute(sqlRestoreDocument, time.Now(), id)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return errors.New("database service not available")
+	}
+
+	_, err := ds.databaseService.db.Exec(sqlRestoreDocument, time.Now().Format("2006-01-02 15:04:05"), id)
 	if err != nil {
 		return fmt.Errorf("failed to restore document: %w", err)
 	}
@@ -358,44 +363,50 @@ func (ds *DocumentService) ListAllDocumentsMeta() ([]*models.Document, error) {
 	ds.mu.RLock()
 	defer ds.mu.RUnlock()
 
-	rows, err := ds.databaseService.SQLite.Query(sqlListAllDocumentsMeta)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return nil, errors.New("database service not available")
+	}
+
+	rows, err := ds.databaseService.db.Query(sqlListAllDocumentsMeta)
 	if err != nil {
 		return nil, fmt.Errorf("failed to list document meta: %w", err)
 	}
+	defer rows.Close()
 
 	var documents []*models.Document
-	for _, row := range rows {
+	for rows.Next() {
 		doc := &models.Document{IsDeleted: false}
+		var createdAt, updatedAt string
+		var isLocked int
 
-		if id, ok := row["id"].(int64); ok {
-			doc.ID = id
+		err := rows.Scan(
+			&doc.ID,
+			&doc.Title,
+			&createdAt,
+			&updatedAt,
+			&isLocked,
+		)
+
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan document row: %w", err)
 		}
 
-		if title, ok := row["title"].(string); ok {
-			doc.Title = title
-		}
-
-		if createdAt, ok := row["created_at"].(string); ok {
-			t, err := time.Parse("2006-01-02 15:04:05", createdAt)
-			if err == nil {
-				doc.CreatedAt = t
-			}
-		}
-
-		if updatedAt, ok := row["updated_at"].(string); ok {
-			t, err := time.Parse("2006-01-02 15:04:05", updatedAt)
-			if err == nil {
-				doc.UpdatedAt = t
-			}
-		}
-
-		if isLockedInt, ok := row["is_locked"].(int64); ok {
-			doc.IsLocked = isLockedInt == 1
+		// 转换时间字段
+		if t, err := time.Parse("2006-01-02 15:04:05", createdAt); err == nil {
+			doc.CreatedAt = t
+		}
+		if t, err := time.Parse("2006-01-02 15:04:05", updatedAt); err == nil {
+			doc.UpdatedAt = t
 		}
 
+		doc.IsLocked = isLocked == 1
 		documents = append(documents, doc)
 	}
 
+	if err = rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating document rows: %w", err)
+	}
+
 	return documents, nil
 }
 
@@ -404,44 +415,50 @@ func (ds *DocumentService) ListDeletedDocumentsMeta() ([]*models.Document, error
 	ds.mu.RLock()
 	defer ds.mu.RUnlock()
 
-	rows, err := ds.databaseService.SQLite.Query(sqlListDeletedDocumentsMeta)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return nil, errors.New("database service not available")
+	}
+
+	rows, err := ds.databaseService.db.Query(sqlListDeletedDocumentsMeta)
 	if err != nil {
 		return nil, fmt.Errorf("failed to list deleted document meta: %w", err)
 	}
+	defer rows.Close()
 
 	var documents []*models.Document
-	for _, row := range rows {
+	for rows.Next() {
 		doc := &models.Document{IsDeleted: true}
+		var createdAt, updatedAt string
+		var isLocked int
 
-		if id, ok := row["id"].(int64); ok {
-			doc.ID = id
+		err := rows.Scan(
+			&doc.ID,
+			&doc.Title,
+			&createdAt,
+			&updatedAt,
+			&isLocked,
+		)
+
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan document row: %w", err)
 		}
 
-		if title, ok := row["title"].(string); ok {
-			doc.Title = title
-		}
-
-		if createdAt, ok := row["created_at"].(string); ok {
-			t, err := time.Parse("2006-01-02 15:04:05", createdAt)
-			if err == nil {
-				doc.CreatedAt = t
-			}
-		}
-
-		if updatedAt, ok := row["updated_at"].(string); ok {
-			t, err := time.Parse("2006-01-02 15:04:05", updatedAt)
-			if err == nil {
-				doc.UpdatedAt = t
-			}
-		}
-
-		if isLockedInt, ok := row["is_locked"].(int64); ok {
-			doc.IsLocked = isLockedInt == 1
+		// 转换时间字段
+		if t, err := time.Parse("2006-01-02 15:04:05", createdAt); err == nil {
+			doc.CreatedAt = t
+		}
+		if t, err := time.Parse("2006-01-02 15:04:05", updatedAt); err == nil {
+			doc.UpdatedAt = t
 		}
 
+		doc.IsLocked = isLocked == 1
 		documents = append(documents, doc)
 	}
 
+	if err = rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating deleted document rows: %w", err)
+	}
+
 	return documents, nil
 }
 
@@ -450,7 +467,12 @@ func (ds *DocumentService) GetFirstDocumentID() (int64, error) {
 	ds.mu.RLock()
 	defer ds.mu.RUnlock()
 
-	rows, err := ds.databaseService.SQLite.Query(sqlGetFirstDocumentID)
+	if ds.databaseService == nil || ds.databaseService.db == nil {
+		return 0, errors.New("database service not available")
+	}
+
+	var id int64
+	err := ds.databaseService.db.QueryRow(sqlGetFirstDocumentID).Scan(&id)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return 0, nil // No documents exist
@@ -458,14 +480,5 @@ func (ds *DocumentService) GetFirstDocumentID() (int64, error) {
 		return 0, fmt.Errorf("failed to get first document ID: %w", err)
 	}
 
-	if len(rows) == 0 {
-		return 0, nil
-	}
-
-	id, ok := rows[0]["id"].(int64)
-	if !ok {
-		return 0, fmt.Errorf("failed to convert ID to int64")
-	}
-
 	return id, nil
 }

internal/services/extension_service.go

@@ -104,21 +104,17 @@ func (es *ExtensionService) initDatabase() error {
 	es.mu.Lock()
 	defer es.mu.Unlock()
 
+	if es.databaseService == nil || es.databaseService.db == nil {
+		return &ExtensionError{"check_db", "", errors.New("database service not available")}
+	}
+
 	// 检查是否已有扩展数据
-	rows, err := es.databaseService.SQLite.Query("SELECT COUNT(*) FROM extensions")
+	var count int64
+	err := es.databaseService.db.QueryRow("SELECT COUNT(*) FROM extensions").Scan(&count)
 	if err != nil {
 		return &ExtensionError{"check_extensions_count", "", err}
 	}
 
-	if len(rows) == 0 {
-		return &ExtensionError{"check_extensions_count", "", fmt.Errorf("no rows returned")}
-	}
-
-	count, ok := rows[0]["COUNT(*)"].(int64)
-	if !ok {
-		return &ExtensionError{"convert_count", "", fmt.Errorf("failed to convert count to int64")}
-	}
-
 	// 如果没有数据，插入默认配置
 	if count == 0 {
 		if err := es.insertDefaultExtensions(); err != nil {
@@ -133,16 +129,15 @@ func (es *ExtensionService) initDatabase() error {
 // insertDefaultExtensions 插入默认扩展配置
 func (es *ExtensionService) insertDefaultExtensions() error {
 	defaultSettings := models.NewDefaultExtensionSettings()
-	now := time.Now()
+	now := time.Now().Format("2006-01-02 15:04:05")
 
 	for _, ext := range defaultSettings.Extensions {
-
 		configJSON, err := json.Marshal(ext.Config)
 		if err != nil {
 			return &ExtensionError{"marshal_config", string(ext.ID), err}
 		}
 
-		err = es.databaseService.SQLite.Execute(sqlInsertExtension,
+		_, err = es.databaseService.db.Exec(sqlInsertExtension,
 			string(ext.ID),
 			ext.Enabled,
 			ext.IsDefault,
@@ -153,7 +148,6 @@ func (es *ExtensionService) insertDefaultExtensions() error {
 		if err != nil {
 			return &ExtensionError{"insert_extension", string(ext.ID), err}
 		}
-
 	}
 
 	return nil
@@ -179,38 +173,51 @@ func (es *ExtensionService) GetAllExtensions() ([]models.Extension, error) {
 	es.mu.RLock()
 	defer es.mu.RUnlock()
 
-	rows, err := es.databaseService.SQLite.Query(sqlGetAllExtensions)
+	if es.databaseService == nil || es.databaseService.db == nil {
+		return nil, &ExtensionError{"query_db", "", errors.New("database service not available")}
+	}
+
+	rows, err := es.databaseService.db.Query(sqlGetAllExtensions)
 	if err != nil {
 		return nil, &ExtensionError{"query_extensions", "", err}
 	}
+	defer rows.Close()
 
 	var extensions []models.Extension
-	for _, row := range rows {
+	for rows.Next() {
 		var ext models.Extension
+		var id string
+		var configJSON string
+		var enabled, isDefault int
 
-		if id, ok := row["id"].(string); ok {
-			ext.ID = models.ExtensionID(id)
+		err := rows.Scan(
+			&id,
+			&enabled,
+			&isDefault,
+			&configJSON,
+		)
+
+		if err != nil {
+			return nil, &ExtensionError{"scan_extension", "", err}
 		}
 
-		if enabled, ok := row["enabled"].(int64); ok {
-			ext.Enabled = enabled == 1
-		}
+		ext.ID = models.ExtensionID(id)
+		ext.Enabled = enabled == 1
+		ext.IsDefault = isDefault == 1
 
-		if isDefault, ok := row["is_default"].(int64); ok {
-			ext.IsDefault = isDefault == 1
-		}
-
-		if configJSON, ok := row["config"].(string); ok {
-			var config models.ExtensionConfig
-			if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
-				return nil, &ExtensionError{"unmarshal_config", string(ext.ID), err}
-			}
-			ext.Config = config
+		var config models.ExtensionConfig
+		if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
+			return nil, &ExtensionError{"unmarshal_config", id, err}
 		}
+		ext.Config = config
 
 		extensions = append(extensions, ext)
 	}
 
+	if err = rows.Err(); err != nil {
+		return nil, &ExtensionError{"iterate_extensions", "", err}
+	}
+
 	return extensions, nil
 }
 
@@ -224,6 +231,10 @@ func (es *ExtensionService) UpdateExtensionState(id models.ExtensionID, enabled
 	es.mu.Lock()
 	defer es.mu.Unlock()
 
+	if es.databaseService == nil || es.databaseService.db == nil {
+		return &ExtensionError{"check_db", string(id), errors.New("database service not available")}
+	}
+
 	var configJSON []byte
 	var err error
 
@@ -234,24 +245,19 @@ func (es *ExtensionService) UpdateExtensionState(id models.ExtensionID, enabled
 		}
 	} else {
 		// 如果没有提供配置，保持原有配置
-		rows, err := es.databaseService.SQLite.Query("SELECT config FROM extensions WHERE id = ?", string(id))
+		var currentConfigJSON string
+		err := es.databaseService.db.QueryRow("SELECT config FROM extensions WHERE id = ?", string(id)).Scan(&currentConfigJSON)
 		if err != nil {
 			return &ExtensionError{"query_current_config", string(id), err}
 		}
-
-		if len(rows) == 0 {
-			return &ExtensionError{"query_current_config", string(id), fmt.Errorf("extension not found")}
-		}
-
-		currentConfigJSON, ok := rows[0]["config"].(string)
-		if !ok {
-			return &ExtensionError{"convert_config", string(id), fmt.Errorf("failed to get current config")}
-		}
-
 		configJSON = []byte(currentConfigJSON)
 	}
 
-	err = es.databaseService.SQLite.Execute(sqlUpdateExtension, enabled, string(configJSON), time.Now(), string(id))
+	_, err = es.databaseService.db.Exec(sqlUpdateExtension,
+		enabled,
+		string(configJSON),
+		time.Now().Format("2006-01-02 15:04:05"),
+		string(id))
 	if err != nil {
 		return &ExtensionError{"update_extension", string(id), err}
 	}
@@ -276,8 +282,12 @@ func (es *ExtensionService) ResetAllExtensionsToDefault() error {
 	es.mu.Lock()
 	defer es.mu.Unlock()
 
+	if es.databaseService == nil || es.databaseService.db == nil {
+		return &ExtensionError{"check_db", "", errors.New("database service not available")}
+	}
+
 	// 删除所有现有扩展
-	err := es.databaseService.SQLite.Execute(sqlDeleteAllExtensions)
+	_, err := es.databaseService.db.Exec(sqlDeleteAllExtensions)
 	if err != nil {
 		return &ExtensionError{"delete_all_extensions", "", err}
 	}

internal/services/keybinding_service.go

@@ -105,21 +105,17 @@ func (kbs *KeyBindingService) initDatabase() error {
 	kbs.mu.Lock()
 	defer kbs.mu.Unlock()
 
+	if kbs.databaseService == nil || kbs.databaseService.db == nil {
+		return &KeyBindingError{"check_db", "", errors.New("database service not available")}
+	}
+
 	// 检查是否已有快捷键数据
-	rows, err := kbs.databaseService.SQLite.Query("SELECT COUNT(*) FROM key_bindings")
+	var count int64
+	err := kbs.databaseService.db.QueryRow("SELECT COUNT(*) FROM key_bindings").Scan(&count)
 	if err != nil {
 		return &KeyBindingError{"check_keybindings_count", "", err}
 	}
 
-	if len(rows) == 0 {
-		return &KeyBindingError{"check_keybindings_count", "", fmt.Errorf("no rows returned")}
-	}
-
-	count, ok := rows[0]["COUNT(*)"].(int64)
-	if !ok {
-		return &KeyBindingError{"convert_count", "", fmt.Errorf("failed to convert count to int64")}
-	}
-
 	// 如果没有数据，插入默认配置
 	if count == 0 {
 		if err := kbs.insertDefaultKeyBindings(); err != nil {
@@ -134,11 +130,10 @@ func (kbs *KeyBindingService) initDatabase() error {
 // insertDefaultKeyBindings 插入默认快捷键配置
 func (kbs *KeyBindingService) insertDefaultKeyBindings() error {
 	defaultConfig := models.NewDefaultKeyBindingConfig()
-	now := time.Now()
+	now := time.Now().Format("2006-01-02 15:04:05")
 
 	for _, kb := range defaultConfig.KeyBindings {
-
-		err := kbs.databaseService.SQLite.Execute(sqlInsertKeyBinding,
+		_, err := kbs.databaseService.db.Exec(sqlInsertKeyBinding,
 			string(kb.Command),   // 转换为字符串存储
 			string(kb.Extension), // 转换为字符串存储
 			kb.Key,
@@ -150,7 +145,6 @@ func (kbs *KeyBindingService) insertDefaultKeyBindings() error {
 		if err != nil {
 			return &KeyBindingError{"insert_keybinding", string(kb.Command), err}
 		}
-
 	}
 
 	return nil
@@ -161,38 +155,46 @@ func (kbs *KeyBindingService) GetAllKeyBindings() ([]models.KeyBinding, error) {
 	kbs.mu.RLock()
 	defer kbs.mu.RUnlock()
 
-	rows, err := kbs.databaseService.SQLite.Query(sqlGetAllKeyBindings)
+	if kbs.databaseService == nil || kbs.databaseService.db == nil {
+		return nil, &KeyBindingError{"query_db", "", errors.New("database service not available")}
+	}
+
+	rows, err := kbs.databaseService.db.Query(sqlGetAllKeyBindings)
 	if err != nil {
 		return nil, &KeyBindingError{"query_keybindings", "", err}
 	}
+	defer rows.Close()
 
 	var keyBindings []models.KeyBinding
-	for _, row := range rows {
+	for rows.Next() {
 		var kb models.KeyBinding
+		var command, extension string
+		var enabled, isDefault int
 
-		if command, ok := row["command"].(string); ok {
-			kb.Command = models.KeyBindingCommand(command)
+		err := rows.Scan(
+			&command,
+			&extension,
+			&kb.Key,
+			&enabled,
+			&isDefault,
+		)
+
+		if err != nil {
+			return nil, &KeyBindingError{"scan_keybinding", "", err}
 		}
 
-		if extension, ok := row["extension"].(string); ok {
-			kb.Extension = models.ExtensionID(extension)
-		}
-
-		if key, ok := row["key"].(string); ok {
-			kb.Key = key
-		}
-
-		if enabled, ok := row["enabled"].(int64); ok {
-			kb.Enabled = enabled == 1
-		}
-
-		if isDefault, ok := row["is_default"].(int64); ok {
-			kb.IsDefault = isDefault == 1
-		}
+		kb.Command = models.KeyBindingCommand(command)
+		kb.Extension = models.ExtensionID(extension)
+		kb.Enabled = enabled == 1
+		kb.IsDefault = isDefault == 1
 
 		keyBindings = append(keyBindings, kb)
 	}
 
+	if err = rows.Err(); err != nil {
+		return nil, &KeyBindingError{"iterate_keybindings", "", err}
+	}
+
 	return keyBindings, nil
 }
 

internal/services/service_manager.go

@@ -5,14 +5,12 @@ import (
 
 	"github.com/wailsapp/wails/v3/pkg/application"
 	"github.com/wailsapp/wails/v3/pkg/services/log"
-	"github.com/wailsapp/wails/v3/pkg/services/sqlite"
 )
 
 // ServiceManager 服务管理器，负责协调各个服务
 type ServiceManager struct {
 	configService      *ConfigService
 	databaseService    *DatabaseService
-	sqliteService      *sqlite.Service
 	documentService    *DocumentService
 	windowService      *WindowService
 	migrationService   *MigrationService
@@ -25,6 +23,7 @@ type ServiceManager struct {
 	startupService     *StartupService
 	selfUpdateService  *SelfUpdateService
 	translationService *TranslationService
+	BackupService      *BackupService
 	logger             *log.Service
 }
 
@@ -36,9 +35,6 @@ func NewServiceManager() *ServiceManager {
 	// 初始化配置服务
 	configService := NewConfigService(logger)
 
-	// 初始化SQLite服务
-	sqliteService := sqlite.New()
-
 	// 初始化数据库服务
 	databaseService := NewDatabaseService(configService, logger)
 
@@ -81,6 +77,9 @@ func NewServiceManager() *ServiceManager {
 	// 初始化翻译服务
 	translationService := NewTranslationService(logger)
 
+	// 初始化备份服务
+	backupService := NewBackupService(configService, databaseService, logger)
+
 	// 使用新的配置通知系统设置热键配置变更监听
 	err = configService.SetHotkeyChangeCallback(func(enable bool, hotkey *models.HotkeyCombo) error {
 		return hotkeyService.UpdateHotkey(enable, hotkey)
@@ -97,10 +96,17 @@ func NewServiceManager() *ServiceManager {
 		panic(err)
 	}
 
+	// 设置备份配置变更监听，处理备份配置变更
+	err = configService.SetBackupConfigChangeCallback(func(config *models.GitBackupConfig) error {
+		return backupService.HandleConfigChange(config)
+	})
+	if err != nil {
+		panic(err)
+	}
+
 	return &ServiceManager{
 		configService:      configService,
 		databaseService:    databaseService,
-		sqliteService:      sqliteService,
 		documentService:    documentService,
 		windowService:      windowService,
 		migrationService:   migrationService,
@@ -113,6 +119,7 @@ func NewServiceManager() *ServiceManager {
 		startupService:     startupService,
 		selfUpdateService:  selfUpdateService,
 		translationService: translationService,
+		BackupService:      backupService,
 		logger:             logger,
 	}
 }
@@ -121,7 +128,6 @@ func NewServiceManager() *ServiceManager {
 func (sm *ServiceManager) GetServices() []application.Service {
 	services := []application.Service{
 		application.NewService(sm.configService),
-		application.NewService(sm.sqliteService),
 		application.NewService(sm.databaseService),
 		application.NewService(sm.documentService),
 		application.NewService(sm.windowService),
@@ -135,6 +141,7 @@ func (sm *ServiceManager) GetServices() []application.Service {
 		application.NewService(sm.startupService),
 		application.NewService(sm.selfUpdateService),
 		application.NewService(sm.translationService),
+		application.NewService(sm.BackupService),
 	}
 	return services
 }
@@ -194,11 +201,6 @@ func (sm *ServiceManager) GetDatabaseService() *DatabaseService {
 	return sm.databaseService
 }
 
-// GetSQLiteService 获取SQLite服务实例
-func (sm *ServiceManager) GetSQLiteService() *sqlite.Service {
-	return sm.sqliteService
-}
-
 // GetWindowService 获取窗口服务实例
 func (sm *ServiceManager) GetWindowService() *WindowService {
 	return sm.windowService