Добавление первой итерации генерации плагина .star

2025-09-11 17:43:21 +03:00
parent 990e091e8b
commit 5b2b370a39
8 changed files with 1017 additions and 16 deletions
--- a/internal/builtins/run_every.go
+++ b/internal/builtins/run_every.go
@@ -116,38 +116,46 @@ var runEveryModule = &starlarkstruct.Module{

 func runEveryMinute(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	var fn *starlark.Function
-	err := starlark.UnpackArgs("run_every.minute", args, kwargs, "function", &fn)
+	var count int64 = 1
+	err := starlark.UnpackArgs("run_every.minute", args, kwargs, "function", &fn, "count?", &count)
 	if err != nil {
 		return nil, err
 	}
-	return runScheduled(thread, fn, "1m")
+	duration := time.Duration(count) * time.Minute
+	return runScheduled(thread, fn, duration.String())
 }

 func runEveryHour(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	var fn *starlark.Function
-	err := starlark.UnpackArgs("run_every.hour", args, kwargs, "function", &fn)
+	var count int64 = 1
+	err := starlark.UnpackArgs("run_every.hour", args, kwargs, "function", &fn, "count?", &count)
 	if err != nil {
 		return nil, err
 	}
-	return runScheduled(thread, fn, "1h")
+	duration := time.Duration(count) * time.Hour
+	return runScheduled(thread, fn, duration.String())
 }

 func runEveryDay(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	var fn *starlark.Function
-	err := starlark.UnpackArgs("run_every.day", args, kwargs, "function", &fn)
+	var count int64 = 1
+	err := starlark.UnpackArgs("run_every.day", args, kwargs, "function", &fn, "count?", &count)
 	if err != nil {
 		return nil, err
 	}
-	return runScheduled(thread, fn, "24h")
+	duration := time.Duration(count) * 24 * time.Hour
+	return runScheduled(thread, fn, duration.String())
 }

 func runEveryWeek(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
 	var fn *starlark.Function
-	err := starlark.UnpackArgs("run_every.week", args, kwargs, "function", &fn)
+	var count int64 = 1
+	err := starlark.UnpackArgs("run_every.week", args, kwargs, "function", &fn, "count?", &count)
 	if err != nil {
 		return nil, err
 	}
-	return runScheduled(thread, fn, "168h")
+	duration := time.Duration(count) * 7 * 24 * time.Hour
+	return runScheduled(thread, fn, duration.String())
 }

 func runScheduled(thread *starlark.Thread, fn *starlark.Function, duration string) (starlark.Value, error) {
--- a/internal/generator/plugin_generator.go
+++ b/internal/generator/plugin_generator.go
@@ -0,0 +1,465 @@
+package generator
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"text/template"
+
+	"gitea.plemya-x.ru/Plemya-x/ALR-updater/internal/config"
+)
+
+// PluginTemplate представляет шаблон плагина
+type PluginTemplate struct {
+	PackageName    string
+	FunctionName   string
+	Repository     string
+	GitHubRepo     string
+	AssetPattern   string
+	URLTemplate    string
+	URLPattern     string
+	VersionPrefix  string
+	Schedule       string
+	ScheduleCalls  string
+}
+
+// PackageInfo содержит информацию о пакете из alr.sh
+type PackageInfo struct {
+	Name        string
+	Version     string
+	Sources     []string
+	Description string
+	Homepage    string
+}
+
+// DetectedPackage содержит автоматически определенную информацию о пакете
+type DetectedPackage struct {
+	PackageInfo
+	GitHubRepo    string
+	PackageType   string
+	AssetPattern  string
+	URLTemplate   string
+	VersionPrefix string
+}
+
+const pluginTemplateStr = `# Repository: {{.Repository}}
+# Auto-generated plugin for {{.PackageName}}
+
+REPO = "{{.Repository}}"
+
+def check_{{.FunctionName}}():
+    """Проверка обновлений для {{.PackageName}} с автоматическим обновлением checksums"""
+    package_name = "{{.PackageName}}"
+    
+    # Обновляем репозиторий перед проверкой
+    updater.pull(REPO)
+    
+    # Получение текущей версии из пакета
+    current_content = updater.get_package_file(REPO, package_name, "alr.sh")
+    # Универсальное распознавание: без кавычек, одинарные кавычки, двойные кавычки
+    current_version_matches = regex.find(r"version=['\"]?([0-9.]+)['\"]?", current_content)
+    
+    if not current_version_matches or len(current_version_matches) == 0:
+        log.error("Не удалось найти текущую версию для " + package_name)
+        return
+    
+    current_version = current_version_matches[0]
+    
+    # Проверка новой версии через GitHub API
+    api_url = "https://api.github.com/repos/{{.GitHubRepo}}/releases/latest"
+    response = http.get(api_url)
+    if not response:
+        log.error("Не удалось получить ответ от GitHub API для " + package_name)
+        return
+    
+    release_data = response.json()
+    if not release_data or "tag_name" not in release_data:
+        log.error("Нет данных о релизе для " + package_name)
+        return
+    
+    # Извлекаем версию из тега{{if .VersionPrefix}} (убираем '{{.VersionPrefix}}' если есть){{end}}
+    tag_name = release_data["tag_name"]
+    {{if .VersionPrefix}}new_version = tag_name[{{len .VersionPrefix}}:] if tag_name.startswith("{{.VersionPrefix}}") else tag_name{{else}}new_version = tag_name[1:] if tag_name.startswith("v") else tag_name{{end}}
+    
+    # Сравнение версий
+    if new_version != current_version:
+        log.info("Обнаружено обновление " + package_name + ": " + current_version + " -> " + new_version)
+        
+        {{if .URLTemplate}}# URL для скачивания по шаблону
+        download_url = "{{.URLTemplate}}".replace("{tag}", tag_name).replace("{version}", new_version){{else if .AssetPattern}}# Находим URL для файла по паттерну
+        download_url = ""
+        if "assets" in release_data:
+            for asset in release_data["assets"]:
+                asset_matches = regex.find(r"{{.AssetPattern}}", asset["name"])
+                if asset_matches and len(asset_matches) > 0:
+                    download_url = asset["browser_download_url"]
+                    break
+        
+        if not download_url:
+            log.error("Не найден подходящий asset для " + package_name)
+            return{{else}}# Ищем первый подходящий asset
+        download_url = ""
+        if "assets" in release_data and len(release_data["assets"]) > 0:
+            download_url = release_data["assets"][0]["browser_download_url"]{{end}}
+        
+        # Обновление версии в файле (сохраняем формат кавычек)
+        # Определяем какой формат используется
+        if regex.find(r"version='[0-9.]+'", current_content):
+            # Одинарные кавычки
+            new_content = regex.replace(
+                current_content,
+                r"version='[0-9.]+'",
+                "version='" + new_version + "'"
+            )
+        elif regex.find(r'version="[0-9.]+"', current_content):
+            # Двойные кавычки
+            new_content = regex.replace(
+                current_content,
+                r'version="[0-9.]+"',
+                'version="' + new_version + '"'
+            )
+        else:
+            # Без кавычек
+            new_content = regex.replace(
+                current_content,
+                r"version=[0-9.]+",
+                "version=" + new_version
+            )
+        
+        {{if .URLPattern}}# Обновление URL загрузки в файле
+        new_content = regex.replace(
+            new_content,
+            r"{{.URLPattern}}",
+            download_url
+        ){{end}}
+        
+        # Вычисление новой хеш-суммы
+        log.info("Вычисление SHA256 для " + download_url)
+        new_checksum = checksum.calculate_sha256(download_url)
+        log.info("Новая хеш-сумма: " + new_checksum)
+        
+        # Обновление файла с новыми checksums
+        updater.update_checksums(
+            REPO,
+            package_name, 
+            "alr.sh", 
+            new_content,
+            [new_checksum]
+        )
+        
+        # Коммит и push изменений
+        updater.push_changes(REPO, package_name + ": обновление до версии " + new_version)
+        
+        log.info("Пакет " + package_name + " успешно обновлён до версии " + new_version + " с новой хеш-суммой")
+    else:
+        log.info("Пакет " + package_name + " уже имеет последнюю версию: " + current_version)
+
+# {{.Schedule}}
+{{.ScheduleCalls}}`
+
+// PluginGenerator представляет генератор плагинов
+type PluginGenerator struct {
+	config      *config.Config
+	template    *template.Template
+	reposDir    string
+	pluginsDir  string
+}
+
+// NewPluginGenerator создает новый генератор плагинов
+func NewPluginGenerator(cfg *config.Config, pluginsDir string) (*PluginGenerator, error) {
+	tmpl, err := template.New("plugin").Parse(pluginTemplateStr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse template: %w", err)
+	}
+
+	return &PluginGenerator{
+		config:     cfg,
+		template:   tmpl,
+		reposDir:   cfg.ReposBaseDir,
+		pluginsDir: pluginsDir,
+	}, nil
+}
+
+// ScanRepository сканирует репозиторий и находит пакеты без плагинов
+func (pg *PluginGenerator) ScanRepository(repoName string) ([]DetectedPackage, error) {
+	repoPath := filepath.Join(pg.reposDir, repoName)
+	if _, err := os.Stat(repoPath); os.IsNotExist(err) {
+		return nil, fmt.Errorf("repository directory not found: %s", repoPath)
+	}
+
+	var packages []DetectedPackage
+
+	err := filepath.Walk(repoPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Ищем файлы alr.sh
+		if info.Name() == "alr.sh" {
+			packageDir := filepath.Dir(path)
+			packageName := filepath.Base(packageDir)
+
+			// Пропускаем если плагин уже существует
+			pluginFile := filepath.Join(pg.pluginsDir, packageName+".star")
+			if _, err := os.Stat(pluginFile); err == nil {
+				return nil
+			}
+
+			// Анализируем пакет
+			pkgInfo, err := pg.analyzePackage(path)
+			if err != nil {
+				fmt.Printf("Warning: failed to analyze package %s: %v\n", packageName, err)
+				return nil
+			}
+
+			detected := pg.detectPackageType(packageName, *pkgInfo)
+			if detected.GitHubRepo != "" {
+				packages = append(packages, detected)
+			}
+		}
+
+		return nil
+	})
+
+	return packages, err
+}
+
+// analyzePackage анализирует файл alr.sh пакета
+func (pg *PluginGenerator) analyzePackage(alrFile string) (*PackageInfo, error) {
+	content, err := os.ReadFile(alrFile)
+	if err != nil {
+		return nil, err
+	}
+
+	info := &PackageInfo{
+		Name: filepath.Base(filepath.Dir(alrFile)),
+	}
+
+	lines := strings.Split(string(content), "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+
+		// Извлекаем версию
+		if strings.HasPrefix(line, "version=") {
+			versionMatch := regexp.MustCompile(`version=['"]?([^'"]+)['"]?`).FindStringSubmatch(line)
+			if len(versionMatch) > 1 {
+				info.Version = versionMatch[1]
+			}
+		}
+
+		// Извлекаем источники
+		if strings.Contains(line, "github.com") || strings.Contains(line, "https://") {
+			urlMatch := regexp.MustCompile(`https://[^\s"']+`).FindAllString(line, -1)
+			info.Sources = append(info.Sources, urlMatch...)
+		}
+
+		// Извлекаем описание
+		if strings.HasPrefix(line, "desc=") {
+			descMatch := regexp.MustCompile(`desc=['"]?([^'"]+)['"]?`).FindStringSubmatch(line)
+			if len(descMatch) > 1 {
+				info.Description = descMatch[1]
+			}
+		}
+
+		// Извлекаем homepage
+		if strings.HasPrefix(line, "homepage=") {
+			homepageMatch := regexp.MustCompile(`homepage=['"]?([^'"]+)['"]?`).FindStringSubmatch(line)
+			if len(homepageMatch) > 1 {
+				info.Homepage = homepageMatch[1]
+			}
+		}
+	}
+
+	return info, nil
+}
+
+// detectPackageType определяет тип пакета и GitHub репозиторий
+func (pg *PluginGenerator) detectPackageType(packageName string, info PackageInfo) DetectedPackage {
+	detected := DetectedPackage{
+		PackageInfo: info,
+		PackageType: "unknown",
+	}
+
+	// Анализируем источники для GitHub репозиториев
+	githubRegex := regexp.MustCompile(`github\.com/([^/]+/[^/]+)`)
+	
+	for _, source := range info.Sources {
+		if match := githubRegex.FindStringSubmatch(source); len(match) > 1 {
+			detected.GitHubRepo = match[1]
+			detected.PackageType = "github_release"
+			break
+		}
+	}
+
+	// Если не найдено в источниках, проверяем homepage
+	if detected.GitHubRepo == "" && info.Homepage != "" {
+		if match := githubRegex.FindStringSubmatch(info.Homepage); len(match) > 1 {
+			detected.GitHubRepo = match[1]
+			detected.PackageType = "github_release"
+		}
+	}
+
+	// Определяем паттерны для разных типов пакетов
+	if strings.HasSuffix(packageName, "-bin") {
+		detected = pg.detectBinaryPackage(packageName, detected)
+	} else if strings.HasSuffix(packageName, "-git") {
+		detected.PackageType = "git_commits"
+	} else {
+		detected = pg.detectSourcePackage(packageName, detected)
+	}
+
+	return detected
+}
+
+// detectBinaryPackage определяет паттерны для бинарных пакетов
+func (pg *PluginGenerator) detectBinaryPackage(packageName string, detected DetectedPackage) DetectedPackage {
+	switch {
+	case strings.Contains(packageName, "telegram"):
+		detected.AssetPattern = `tsetup\..*\.tar\.xz`
+		detected.URLTemplate = "https://github.com/telegramdesktop/tdesktop/releases/download/{tag}/tsetup.{version}.tar.xz"
+	case strings.Contains(packageName, "discord"):
+		detected.AssetPattern = `.*\.tar\.gz$`
+	case strings.Contains(packageName, "obsidian"):
+		detected.AssetPattern = `.*\.AppImage$`
+	case strings.Contains(packageName, "electron"):
+		detected.AssetPattern = `.*-linux-x64\.zip$`
+	case strings.Contains(packageName, "vscode") || strings.Contains(packageName, "code"):
+		detected.AssetPattern = `.*\.tar\.gz$`
+	default:
+		// Общие паттерны для бинарных пакетов
+		detected.AssetPattern = `.*linux.*\.(tar\.gz|tar\.xz|zip|AppImage)$`
+	}
+
+	return detected
+}
+
+// detectSourcePackage определяет паттерны для исходных пакетов
+func (pg *PluginGenerator) detectSourcePackage(packageName string, detected DetectedPackage) DetectedPackage {
+	// Для большинства исходных пакетов используем архив тега
+	detected.URLTemplate = "https://github.com/{repo}/archive/{tag}.tar.gz"
+	
+	// Специальные случаи
+	switch packageName {
+	case "md4c":
+		detected.VersionPrefix = "release-"
+	case "steamcmd":
+		detected.PackageType = "http_lastmodified"
+	}
+
+	return detected
+}
+
+// GeneratePlugin генерирует плагин для пакета
+func (pg *PluginGenerator) GeneratePlugin(detected DetectedPackage, repoName string) error {
+	functionName := strings.ReplaceAll(strings.ReplaceAll(detected.Name, "-", "_"), ".", "_")
+	
+	schedule := pg.determineSchedule(detected)
+	scheduleCalls := pg.generateScheduleCalls(functionName, schedule)
+
+	data := PluginTemplate{
+		PackageName:   detected.Name,
+		FunctionName:  functionName,
+		Repository:    repoName,
+		GitHubRepo:    detected.GitHubRepo,
+		AssetPattern:  detected.AssetPattern,
+		URLTemplate:   detected.URLTemplate,
+		URLPattern:    pg.generateURLPattern(detected),
+		VersionPrefix: detected.VersionPrefix,
+		Schedule:      schedule,
+		ScheduleCalls: scheduleCalls,
+	}
+
+	pluginFile := filepath.Join(pg.pluginsDir, detected.Name+".star")
+	file, err := os.Create(pluginFile)
+	if err != nil {
+		return fmt.Errorf("failed to create plugin file: %w", err)
+	}
+	defer file.Close()
+
+	err = pg.template.Execute(file, data)
+	if err != nil {
+		return fmt.Errorf("failed to execute template: %w", err)
+	}
+
+	fmt.Printf("✅ Generated plugin: %s\n", pluginFile)
+	return nil
+}
+
+// determineSchedule определяет расписание проверки обновлений
+func (pg *PluginGenerator) determineSchedule(detected DetectedPackage) string {
+	switch {
+	case strings.HasSuffix(detected.Name, "-bin"):
+		return "Запуск проверки каждые 6 часов"
+	case strings.Contains(detected.Name, "lib") || strings.Contains(detected.Name, "cmake"):
+		return "Запуск проверки каждую неделю"
+	default:
+		return "Запуск проверки каждый день"
+	}
+}
+
+// generateScheduleCalls генерирует вызовы функций расписания
+func (pg *PluginGenerator) generateScheduleCalls(functionName, schedule string) string {
+	switch {
+	case strings.Contains(schedule, "6 часов"):
+		return fmt.Sprintf("run_every.hour(check_%s, 6)", functionName)
+	case strings.Contains(schedule, "день"):
+		return fmt.Sprintf("run_every.day(check_%s)", functionName)
+	case strings.Contains(schedule, "неделю"):
+		return fmt.Sprintf("run_every.week(check_%s)", functionName)
+	default:
+		return fmt.Sprintf("run_every.day(check_%s)", functionName)
+	}
+}
+
+// generateURLPattern генерирует regex паттерн для обновления URL в файле
+func (pg *PluginGenerator) generateURLPattern(detected DetectedPackage) string {
+	if detected.URLTemplate != "" {
+		return "" // URL pattern будет сгенерирован автоматически
+	}
+
+	// Базовые паттерны для разных типов
+	switch detected.GitHubRepo {
+	case "telegramdesktop/tdesktop":
+		return `https://github\.com/telegramdesktop/tdesktop/releases/download/[^/]+/tsetup\.[0-9.]+\.tar\.xz`
+	case "obsidianmd/obsidian-releases":
+		return `https://github\.com/obsidianmd/obsidian-releases/releases/download/[^/]+/Obsidian-[0-9.]+\.AppImage`
+	default:
+		return `https://github\.com/` + strings.ReplaceAll(detected.GitHubRepo, "/", `\/`) + `/releases/download/[^/]+/.*`
+	}
+}
+
+// GenerateAllPlugins сканирует все репозитории и генерирует недостающие плагины
+func (pg *PluginGenerator) GenerateAllPlugins() error {
+	var totalGenerated int
+
+	for repoName := range pg.config.Repositories {
+		fmt.Printf("🔍 Сканирование репозитория %s...\n", repoName)
+		
+		packages, err := pg.ScanRepository(repoName)
+		if err != nil {
+			fmt.Printf("Warning: failed to scan repository %s: %v\n", repoName, err)
+			continue
+		}
+
+		fmt.Printf("Найдено %d пакетов без плагинов\n", len(packages))
+
+		for _, pkg := range packages {
+			if pkg.GitHubRepo == "" {
+				fmt.Printf("⚠️  Пропущен %s: GitHub репозиторий не определен\n", pkg.Name)
+				continue
+			}
+
+			err := pg.GeneratePlugin(pkg, repoName)
+			if err != nil {
+				fmt.Printf("❌ Ошибка генерации плагина для %s: %v\n", pkg.Name, err)
+				continue
+			}
+			totalGenerated++
+		}
+	}
+
+	fmt.Printf("\n🎉 Всего сгенерировано %d плагинов\n", totalGenerated)
+	return nil
+}