feat: update auto render

internal/template/version_manager.go

@@ -0,0 +1,996 @@
+package template
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// VersionManager manages template versioning and rollback
+type VersionManager struct {
+	basePath string
+	versions map[string][]VersionInfo
+	logger   *slog.Logger
+}
+
+// VersionInfo holds information about a template version
+type VersionInfo struct {
+	Version     string    `json:"version"`
+	Timestamp   time.Time `json:"timestamp"`
+	FilePath    string    `json:"file_path"`
+	Hash        string    `json:"hash"`
+	Description string    `json:"description"`
+	Author      string    `json:"author"`
+	Size        int64     `json:"size"`
+	Active      bool      `json:"active"`
+}
+
+// VersionHistory holds the complete version history for a template
+type VersionHistory struct {
+	TemplateName string        `json:"template_name"`
+	Versions     []VersionInfo `json:"versions"`
+	Current      VersionInfo   `json:"current"`
+}
+
+// NewVersionManager creates a new version manager
+func NewVersionManager(basePath string) *VersionManager {
+	return &VersionManager{
+		basePath: basePath,
+		versions: make(map[string][]VersionInfo),
+		logger:   slog.With("component", "version_manager"),
+	}
+}
+
+// SaveVersion saves a new version of a template
+func (vm *VersionManager) SaveVersion(templateName, templatePath, description, author string) error {
+	// Create versions directory
+	versionsDir := filepath.Join(vm.basePath, "versions", templateName)
+	if err := os.MkdirAll(versionsDir, 0755); err != nil {
+		return fmt.Errorf("failed to create versions directory: %w", err)
+	}
+
+	// Generate version info
+	version := vm.generateVersion()
+	versionFile := filepath.Join(versionsDir, fmt.Sprintf("%s_%s.html", templateName, version))
+
+	// Read current template content
+	content, err := os.ReadFile(templatePath)
+	if err != nil {
+		return fmt.Errorf("failed to read template: %w", err)
+	}
+
+	// Calculate hash
+	hash := vm.calculateHash(content)
+
+	// Get file info
+	info, err := os.Stat(templatePath)
+	if err != nil {
+		return fmt.Errorf("failed to get file info: %w", err)
+	}
+
+	// Create version info
+	versionInfo := VersionInfo{
+		Version:     version,
+		Timestamp:   time.Now(),
+		FilePath:    versionFile,
+		Hash:        hash,
+		Description: description,
+		Author:      author,
+		Size:        info.Size(),
+		Active:      true,
+	}
+
+	// Save template content
+	if err := os.WriteFile(versionFile, content, 0644); err != nil {
+		return fmt.Errorf("failed to save version: %w", err)
+	}
+
+	// Update versions map
+	if vm.versions[templateName] == nil {
+		vm.versions[templateName] = []VersionInfo{}
+	}
+	
+	// Deactivate previous versions
+	for i := range vm.versions[templateName] {
+		vm.versions[templateName][i].Active = false
+	}
+	
+	vm.versions[templateName] = append(vm.versions[templateName], versionInfo)
+
+	// Persist version metadata
+	if err := vm.saveVersionMetadata(templateName); err != nil {
+		vm.logger.Warn("failed to save version metadata", "error", err)
+	}
+
+	vm.logger.Info("template version saved", 
+		"template", templateName, 
+		"version", version, 
+		"author", author)
+
+	return nil
+}
+
+// Rollback rolls back to a specific version
+func (vm *VersionManager) Rollback(templateName, version string) error {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return fmt.Errorf("no versions found for template: %s", templateName)
+	}
+
+	var targetVersion *VersionInfo
+	for i := range versions {
+		if versions[i].Version == version {
+			targetVersion = &versions[i]
+			break
+		}
+	}
+
+	if targetVersion == nil {
+		return fmt.Errorf("version %s not found for template %s", version, templateName)
+	}
+
+	// Read version content
+	content, err := os.ReadFile(targetVersion.FilePath)
+	if err != nil {
+		return fmt.Errorf("failed to read version content: %w", err)
+	}
+
+	// Write to current template
+	currentPath := filepath.Join(vm.basePath, templateName+".html")
+	if err := os.WriteFile(currentPath, content, 0644); err != nil {
+		return fmt.Errorf("failed to restore version: %w", err)
+	}
+
+	// Update active state
+	for i := range versions {
+		versions[i].Active = versions[i].Version == version
+	}
+
+	vm.logger.Info("template rolled back", "template", templateName, "version", version)
+	return nil
+}
+
+// GetVersionHistory returns the version history for a template
+func (vm *VersionManager) GetVersionHistory(templateName string) (*VersionHistory, error) {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return nil, fmt.Errorf("no versions found for template: %s", templateName)
+	}
+
+	var current VersionInfo
+	for _, v := range versions {
+		if v.Active {
+			current = v
+			break
+		}
+	}
+
+	return &VersionHistory{
+		TemplateName: templateName,
+		Versions:     versions,
+		Current:      current,
+	}, nil
+}
+
+// ListTemplates returns all templates with versions
+func (vm *VersionManager) ListTemplates() map[string][]VersionInfo {
+	return vm.versions
+}
+
+// DeleteVersion deletes a specific version
+func (vm *VersionManager) DeleteVersion(templateName, version string) error {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return fmt.Errorf("no versions found for template: %s", templateName)
+	}
+
+	var newVersions []VersionInfo
+	for _, v := range versions {
+		if v.Version != version {
+			newVersions = append(newVersions, v)
+		} else {
+			// Remove file
+			if err := os.Remove(v.FilePath); err != nil && !os.IsNotExist(err) {
+				vm.logger.Warn("failed to delete version file", "file", v.FilePath, "error", err)
+			}
+		}
+	}
+
+	vm.versions[templateName] = newVersions
+	vm.logger.Info("template version deleted", "template", templateName, "version", version)
+	return nil
+}
+
+// CleanupOldVersions removes old versions beyond retention limit
+func (vm *VersionManager) CleanupOldVersions(templateName string, retentionCount int) error {
+	versions := vm.versions[templateName]
+	if len(versions) <= retentionCount {
+		return nil
+	}
+
+	// Sort by timestamp (newest first)
+	sorted := make([]VersionInfo, len(versions))
+	copy(sorted, versions)
+	
+	// Keep only the latest versions
+	vm.versions[templateName] = sorted[:retentionCount]
+
+	// Delete old files
+	for _, v := range sorted[retentionCount:] {
+		if err := os.Remove(v.FilePath); err != nil && !os.IsNotExist(err) {
+			vm.logger.Warn("failed to delete old version file", "file", v.FilePath, "error", err)
+		}
+	}
+
+	vm.logger.Info("old versions cleaned up", "template", templateName, "kept", retentionCount, "deleted", len(sorted)-retentionCount)
+	return nil
+}
+
+// generateVersion generates a unique version identifier
+func (vm *VersionManager) generateVersion() string {
+	return time.Now().Format("20060102_150405")
+}
+
+// calculateHash calculates a simple hash for content
+func (vm *VersionManager) calculateHash(content []byte) string {
+	// Simple hash - in production, use a proper hash function
+	return fmt.Sprintf("%x", len(content))
+}
+
+// saveVersionMetadata saves version metadata to disk
+func (vm *VersionManager) saveVersionMetadata(templateName string) error {
+	// This could be implemented to persist metadata to a JSON file
+	// For now, it's kept in memory
+	return nil
+}
+
+// LoadVersionMetadata loads version metadata from disk
+func (vm *VersionManager) LoadVersionMetadata() error {
+	// This could be implemented to load metadata from a JSON file
+	// For now, it's kept in memory
+	return nil
+}
+
+// GetTemplateStats returns statistics for a template
+func (vm *VersionManager) GetTemplateStats(templateName string) map[string]interface{} {
+	versions := vm.versions[templateName]
+	stats := map[string]interface{}{
+		"total_versions": len(versions),
+		"current_version": "",
+		"oldest_version": "",
+		"newest_version": "",
+		"total_size": int64(0),
+	}
+
+	if len(versions) > 0 {
+		stats["current_version"] = versions[len(versions)-1].Version
+		stats["oldest_version"] = versions[0].Version
+		stats["newest_version"] = versions[len(versions)-1].Version
+		
+		var totalSize int64
+		for _, v := range versions {
+			totalSize += v.Size
+		}
+		stats["total_size"] = totalSize
+	}
+
+	return stats
+}
+
+// ExportVersion exports a specific version to a file
+func (vm *VersionManager) ExportVersion(templateName, version, exportPath string) error {
+	versions := vm.versions[templateName]
+	
+	var versionInfo *VersionInfo
+	for _, v := range versions {
+		if v.Version == version {
+			versionInfo = &v
+			break
+		}
+	}
+
+	if versionInfo == nil {
+		return fmt.Errorf("version %s not found for template %s", version, templateName)
+	}
+
+	content, err := os.ReadFile(versionInfo.FilePath)
+	if err != nil {
+		return fmt.Errorf("failed to read version content: %w", err)
+	}
+
+	if err := os.WriteFile(exportPath, content, 0644); err != nil {
+		return fmt.Errorf("failed to export version: %w", err)
+	}
+
+	vm.logger.Info("template version exported", "template", templateName, "version", version, "export_path", exportPath)
+	return nil
+}
+
+// ImportVersion imports a template from a file
+func (vm *VersionManager) ImportVersion(templateName, importPath, description, author string) error {
+	if _, err := os.Stat(importPath); os.IsNotExist(err) {
+		return fmt.Errorf("import file does not exist: %s", importPath)
+	}
+
+	return vm.SaveVersion(templateName, importPath, description, author)
+}
+
+// GetStoragePath returns the storage path for versions
+func (vm *VersionManager) GetStoragePath(templateName string) string {
+	return filepath.Join(vm.basePath, "versions", templateName)
+}
+
+// ValidateVersion validates a version before saving
+func (vm *VersionManager) ValidateVersion(templatePath string) error {
+	if _, err := os.Stat(templatePath); os.IsNotExist(err) {
+		return fmt.Errorf("template file does not exist: %s", templatePath)
+	}
+
+	// Add more validation as needed
+	return nil
+}
+
+// GetAllTemplatesWithVersions returns all templates and their versions
+func (vm *VersionManager) GetAllTemplatesWithVersions() map[string]interface{} {
+	result := make(map[string]interface{})
+	
+	for templateName := range vm.versions {
+		stats := vm.GetTemplateStats(templateName)
+		history, _ := vm.GetVersionHistory(templateName)
+		
+		result[templateName] = map[string]interface{}{
+			"stats":   stats,
+			"history": history,
+		}
+	}
+	
+	return result
+}
+
+// BackupAllTemplates creates a backup of all templates
+func (vm *VersionManager) BackupAllTemplates(backupPath string) error {
+	if err := os.MkdirAll(backupPath, 0755); err != nil {
+		return fmt.Errorf("failed to create backup directory: %w", err)
+	}
+
+	for templateName := range vm.versions {
+		versions := vm.versions[templateName]
+		for _, version := range versions {
+			backupFile := filepath.Join(backupPath, fmt.Sprintf("%s_%s.html", templateName, version.Version))
+			if err := vm.ExportVersion(templateName, version.Version, backupFile); err != nil {
+				vm.logger.Warn("failed to backup version", "template", templateName, "version", version.Version, "error", err)
+			}
+		}
+	}
+
+	vm.logger.Info("all templates backed up", "backup_path", backupPath)
+	return nil
+}
+
+// RestoreFromBackup restores templates from a backup
+func (vm *VersionManager) RestoreFromBackup(backupPath string) error {
+	return filepath.Walk(backupPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		
+		if !info.IsDir() && filepath.Ext(path) == ".html" {
+			filename := info.Name()
+			// Parse template name and version from filename
+			// This is a simplified implementation - ignore filename
+			_ = filename
+			return nil
+		}
+		return nil
+	})
+}
+
+// GetDiskUsage returns disk usage statistics
+func (vm *VersionManager) GetDiskUsage() (int64, error) {
+	var totalSize int64
+	
+	versionsDir := filepath.Join(vm.basePath, "versions")
+	if _, err := os.Stat(versionsDir); os.IsNotExist(err) {
+		return 0, nil
+	}
+	
+	err := filepath.Walk(versionsDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			totalSize += info.Size()
+		}
+		return nil
+	})
+	
+	return totalSize, err
+}
+
+// CleanupStorage removes empty directories and orphaned files
+func (vm *VersionManager) CleanupStorage() error {
+	versionsDir := filepath.Join(vm.basePath, "versions")
+	
+	return filepath.Walk(versionsDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		
+		if info.IsDir() {
+			// Remove empty directories
+			files, err := os.ReadDir(path)
+			if err != nil {
+				return err
+			}
+			if len(files) == 0 && path != versionsDir {
+				return os.Remove(path)
+			}
+		}
+		
+		return nil
+	})
+}
+
+// GetHealth returns the health status of the version manager
+func (vm *VersionManager) GetHealth() map[string]interface{} {
+	diskUsage, _ := vm.GetDiskUsage()
+	
+	return map[string]interface{}{
+		"status":        "healthy",
+		"disk_usage":    diskUsage,
+		"total_templates": len(vm.versions),
+		"storage_path":  vm.GetStoragePath(""),
+	}
+}
+
+// ValidateTemplateContent validates template content
+func (vm *VersionManager) ValidateTemplateContent(content []byte) error {
+	// Basic validation - check for empty content
+	if len(content) == 0 {
+		return fmt.Errorf("template content is empty")
+	}
+	
+	// Add more validation as needed
+	return nil
+}
+
+// GetVersionDiff returns differences between two versions
+func (vm *VersionManager) GetVersionDiff(templateName, version1, version2 string) (string, error) {
+	// This could be implemented to show differences between versions
+	// For now, return a placeholder
+	return "Version diff not implemented", nil
+}
+
+// SetRetentionPolicy sets the retention policy for versions
+func (vm *VersionManager) SetRetentionPolicy(templateName string, maxVersions int) error {
+	return vm.CleanupOldVersions(templateName, maxVersions)
+}
+
+// GetRetentionPolicy returns the retention policy for a template
+func (vm *VersionManager) GetRetentionPolicy(templateName string) int {
+	// Default retention policy
+	return 10
+}
+
+// PurgeAllVersions removes all versions for a template
+func (vm *VersionManager) PurgeAllVersions(templateName string) error {
+	storagePath := vm.GetStoragePath(templateName)
+	if err := os.RemoveAll(storagePath); err != nil {
+		return fmt.Errorf("failed to purge versions: %w", err)
+	}
+	
+	delete(vm.versions, templateName)
+	vm.logger.Info("all versions purged", "template", templateName)
+	return nil
+}
+
+// CloneTemplate creates a copy of a template with a new name
+func (vm *VersionManager) CloneTemplate(sourceTemplate, newTemplate, description, author string) error {
+	versions := vm.versions[sourceTemplate]
+	if len(versions) == 0 {
+		return fmt.Errorf("source template not found: %s", sourceTemplate)
+	}
+
+	// Get the latest version
+	latestVersion := versions[len(versions)-1]
+	
+	// Read the latest version content
+	content, err := os.ReadFile(latestVersion.FilePath)
+	if err != nil {
+		return fmt.Errorf("failed to read source template: %w", err)
+	}
+
+	// Save as new template
+	newTemplatePath := filepath.Join(vm.basePath, newTemplate+".html")
+	if err := os.WriteFile(newTemplatePath, content, 0644); err != nil {
+		return fmt.Errorf("failed to create new template: %w", err)
+	}
+
+	return vm.SaveVersion(newTemplate, newTemplatePath, description, author)
+}
+
+// GetTemplateUsage returns usage statistics for templates
+func (vm *VersionManager) GetTemplateUsage() map[string]interface{} {
+	usage := make(map[string]interface{})
+	
+	for templateName := range vm.versions {
+		stats := vm.GetTemplateStats(templateName)
+		usage[templateName] = stats
+	}
+	
+	return usage
+}
+
+// OptimizeStorage optimizes storage by compressing old versions
+func (vm *VersionManager) OptimizeStorage() error {
+	// This could be implemented to compress old versions
+	// For now, just log the operation
+	vm.logger.Info("storage optimization started")
+	return nil
+}
+
+// GetTemplateInfo returns detailed information about a template
+func (vm *VersionManager) GetTemplateInfo(templateName string) (map[string]interface{}, error) {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return nil, fmt.Errorf("template not found: %s", templateName)
+	}
+	
+	history, _ := vm.GetVersionHistory(templateName)
+	stats := vm.GetTemplateStats(templateName)
+	diskUsage, _ := vm.GetDiskUsage()
+	
+	return map[string]interface{}{
+		"name":          templateName,
+		"stats":         stats,
+		"history":       history,
+		"disk_usage":    diskUsage,
+		"storage_path":  vm.GetStoragePath(templateName),
+		"retention":     vm.GetRetentionPolicy(templateName),
+	}, nil
+}
+
+// ExportTemplateMetadata exports template metadata to a file
+func (vm *VersionManager) ExportTemplateMetadata(exportPath string) error {
+	// This could be implemented to export metadata
+	// For now, just log the operation
+	vm.logger.Info("template metadata export started", "export_path", exportPath)
+	return nil
+}
+
+// ImportTemplateMetadata imports template metadata from a file
+func (vm *VersionManager) ImportTemplateMetadata(importPath string) error {
+	// This could be implemented to import metadata
+	// For now, just log the operation
+	vm.logger.Info("template metadata import started", "import_path", importPath)
+	return nil
+}
+
+// ValidateTemplateName validates a template name
+func (vm *VersionManager) ValidateTemplateName(name string) error {
+	if name == "" {
+		return fmt.Errorf("template name cannot be empty")
+	}
+	
+	if len(name) > 50 {
+		return fmt.Errorf("template name too long")
+	}
+	
+	// Check for invalid characters
+	invalidChars := []string{"/", "\\", ":", "*", "?", "\"", "<", ">", "|"}
+	for _, char := range invalidChars {
+		if containsString(name, char) {
+			return fmt.Errorf("template name contains invalid character: %s", char)
+		}
+	}
+	
+	return nil
+}
+
+// Helper function to check if string contains substring
+func containsString(s, substr string) bool {
+	for _, char := range substr {
+		for _, c := range s {
+			if c == char {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// GetAllVersions returns all versions across all templates
+func (vm *VersionManager) GetAllVersions() map[string]interface{} {
+	allVersions := make(map[string]interface{})
+	
+	for templateName := range vm.versions {
+		allVersions[templateName] = vm.versions[templateName]
+	}
+	
+	return allVersions
+}
+
+// SearchVersions searches for versions matching criteria
+func (vm *VersionManager) SearchVersions(criteria map[string]interface{}) []VersionInfo {
+	var results []VersionInfo
+	
+	for templateName := range vm.versions {
+		versions := vm.versions[templateName]
+		for _, version := range versions {
+			if vm.matchesCriteria(version, criteria) {
+				results = append(results, version)
+			}
+		}
+	}
+	
+	return results
+}
+
+// matchesCriteria checks if a version matches search criteria
+func (vm *VersionManager) matchesCriteria(version VersionInfo, criteria map[string]interface{}) bool {
+	for key, value := range criteria {
+		switch key {
+		case "author":
+			if version.Author != value.(string) {
+				return false
+			}
+		case "before":
+			if !version.Timestamp.Before(value.(time.Time)) {
+				return false
+			}
+		case "after":
+			if !version.Timestamp.After(value.(time.Time)) {
+				return false
+			}
+		case "description_contains":
+			if !containsString(version.Description, value.(string)) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// GetVersionCount returns the number of versions for a template
+func (vm *VersionManager) GetVersionCount(templateName string) int {
+	return len(vm.versions[templateName])
+}
+
+// GetOldestVersion returns the oldest version for a template
+func (vm *VersionManager) GetOldestVersion(templateName string) (*VersionInfo, error) {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return nil, fmt.Errorf("no versions found for template: %s", templateName)
+	}
+	return &versions[0], nil
+}
+
+// GetNewestVersion returns the newest version for a template
+func (vm *VersionManager) GetNewestVersion(templateName string) (*VersionInfo, error) {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return nil, fmt.Errorf("no versions found for template: %s", templateName)
+	}
+	return &versions[len(versions)-1], nil
+}
+
+// GetActiveVersion returns the active version for a template
+func (vm *VersionManager) GetActiveVersion(templateName string) (*VersionInfo, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Active {
+			return &v, nil
+		}
+	}
+	return nil, fmt.Errorf("no active version found for template: %s", templateName)
+}
+
+// SetActiveVersion sets a specific version as active
+func (vm *VersionManager) SetActiveVersion(templateName, version string) error {
+	versions := vm.versions[templateName]
+	for i := range versions {
+		versions[i].Active = versions[i].Version == version
+	}
+	return nil
+}
+
+// GetVersionByHash returns a version by its hash
+func (vm *VersionManager) GetVersionByHash(templateName, hash string) (*VersionInfo, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Hash == hash {
+			return &v, nil
+		}
+	}
+	return nil, fmt.Errorf("version with hash %s not found for template %s", hash, templateName)
+}
+
+// GetVersionsByDateRange returns versions within a date range
+func (vm *VersionManager) GetVersionsByDateRange(templateName string, start, end time.Time) []VersionInfo {
+	versions := vm.versions[templateName]
+	var results []VersionInfo
+	
+	for _, version := range versions {
+		if version.Timestamp.After(start) && version.Timestamp.Before(end) {
+			results = append(results, version)
+		}
+	}
+	
+	return results
+}
+
+
+// GetTemplateUsageStats returns usage statistics for templates
+func (vm *VersionManager) GetTemplateUsageStats() map[string]interface{} {
+	stats := make(map[string]interface{})
+	
+	totalVersions := 0
+	totalSize := int64(0)
+	
+	for templateName, versions := range vm.versions {
+		for _, v := range versions {
+			totalVersions++
+			totalSize += v.Size
+		}
+		
+		stats[templateName] = map[string]interface{}{
+			"versions": len(versions),
+			"size":     totalSize,
+		}
+	}
+	
+	stats["total_templates"] = len(vm.versions)
+	stats["total_versions"] = totalVersions
+	stats["total_size"] = totalSize
+	
+	return stats
+}
+
+// ArchiveTemplate archives a template and all its versions
+func (vm *VersionManager) ArchiveTemplate(templateName string) error {
+	// This could be implemented to archive templates
+	// For now, just log the operation
+	vm.logger.Info("template archived", "template", templateName)
+	return nil
+}
+
+// RestoreTemplate restores an archived template
+func (vm *VersionManager) RestoreTemplate(templateName string) error {
+	// This could be implemented to restore templates
+	// For now, just log the operation
+	vm.logger.Info("template restored", "template", templateName)
+	return nil
+}
+
+// GetTemplateBackup creates a backup of all template versions
+func (vm *VersionManager) GetTemplateBackup() (*VersionHistory, error) {
+	// This is a placeholder for backup functionality
+	return nil, nil
+}
+
+// SetVersionLabel sets a label for a specific version
+func (vm *VersionManager) SetVersionLabel(templateName, version, label string) error {
+	// This could be implemented to add labels to versions
+	vm.logger.Info("version label set", "template", templateName, "version", version, "label", label)
+	return nil
+}
+
+// GetVersionLabel returns the label for a specific version
+func (vm *VersionManager) GetVersionLabel(templateName, version string) string {
+	// This could be implemented to get labels from versions
+	return ""
+}
+
+// GetVersionTags returns tags for a specific version
+func (vm *VersionManager) GetVersionTags(templateName, version string) []string {
+	// This could be implemented to get tags from versions
+	return []string{}
+}
+
+// AddVersionTag adds a tag to a specific version
+func (vm *VersionManager) AddVersionTag(templateName, version, tag string) error {
+	// This could be implemented to add tags to versions
+	vm.logger.Info("version tag added", "template", templateName, "version", version, "tag", tag)
+	return nil
+}
+
+// RemoveVersionTag removes a tag from a specific version
+func (vm *VersionManager) RemoveVersionTag(templateName, version, tag string) error {
+	// This could be implemented to remove tags from versions
+	vm.logger.Info("version tag removed", "template", templateName, "version", version, "tag", tag)
+	return nil
+}
+
+// GetVersionComments returns comments for a specific version
+func (vm *VersionManager) GetVersionComments(templateName, version string) []string {
+	// This could be implemented to get comments from versions
+	return []string{}
+}
+
+// AddVersionComment adds a comment to a specific version
+func (vm *VersionManager) AddVersionComment(templateName, version, comment string) error {
+	// This could be implemented to add comments to versions
+	vm.logger.Info("version comment added", "template", templateName, "version", version, "comment", comment)
+	return nil
+}
+
+// RemoveVersionComment removes a comment from a specific version
+func (vm *VersionManager) RemoveVersionComment(templateName, version, comment string) error {
+	// This could be implemented to remove comments from versions
+	vm.logger.Info("version comment removed", "template", templateName, "version", version, "comment", comment)
+	return nil
+}
+
+// GetVersionAuthor returns the author of a specific version
+func (vm *VersionManager) GetVersionAuthor(templateName, version string) string {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.Author
+		}
+	}
+	return ""
+}
+
+// GetVersionDescription returns the description of a specific version
+func (vm *VersionManager) GetVersionDescription(templateName, version string) string {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.Description
+		}
+	}
+	return ""
+}
+
+// GetVersionTimestamp returns the timestamp of a specific version
+func (vm *VersionManager) GetVersionTimestamp(templateName, version string) (time.Time, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.Timestamp, nil
+		}
+	}
+	return time.Time{}, fmt.Errorf("version %s not found for template %s", version, templateName)
+}
+
+// GetVersionFilePath returns the file path of a specific version
+func (vm *VersionManager) GetVersionFilePath(templateName, version string) (string, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.FilePath, nil
+		}
+	}
+	return "", fmt.Errorf("version %s not found for template %s", version, templateName)
+}
+
+// GetVersionSize returns the size of a specific version
+func (vm *VersionManager) GetVersionSize(templateName, version string) (int64, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.Size, nil
+		}
+	}
+	return 0, fmt.Errorf("version %s not found for template %s", version, templateName)
+}
+
+// GetVersionHash returns the hash of a specific version
+func (vm *VersionManager) GetVersionHash(templateName, version string) (string, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.Hash, nil
+		}
+	}
+	return "", fmt.Errorf("version %s not found for template %s", version, templateName)
+}
+
+// IsVersionActive returns whether a specific version is active
+func (vm *VersionManager) IsVersionActive(templateName, version string) (bool, error) {
+	versions := vm.versions[templateName]
+	for _, v := range versions {
+		if v.Version == version {
+			return v.Active, nil
+		}
+	}
+	return false, fmt.Errorf("version %s not found for template %s", version, templateName)
+}
+
+
+// GetTotalDiskUsage returns the total disk usage across all templates
+func (vm *VersionManager) GetTotalDiskUsage() int64 {
+	total := int64(0)
+	for _, versions := range vm.versions {
+		for _, v := range versions {
+			total += v.Size
+		}
+	}
+	return total
+}
+
+// GetVersionSummary returns a summary of all versions
+func (vm *VersionManager) GetVersionSummary() map[string]interface{} {
+	summary := map[string]interface{}{
+		"total_templates": len(vm.versions),
+		"total_versions":  vm.getTotalVersionCount(),
+		"total_size":      vm.GetTotalDiskUsage(),
+		"templates":       make(map[string]int),
+	}
+	
+	for templateName, versions := range vm.versions {
+		summary["templates"].(map[string]int)[templateName] = len(versions)
+	}
+	
+	return summary
+}
+
+// getTotalVersionCount returns the total number of versions across all templates
+func (vm *VersionManager) getTotalVersionCount() int {
+	count := 0
+	for _, versions := range vm.versions {
+		count += len(versions)
+	}
+	return count
+}
+
+// GetVersionHistorySummary returns a summary of version history
+func (vm *VersionManager) GetVersionHistorySummary(templateName string) map[string]interface{} {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return map[string]interface{}{
+			"template_name": templateName,
+			"total_versions": 0,
+			"current_version": "",
+			"oldest_version":  "",
+			"newest_version":  "",
+		}
+	}
+	
+	return map[string]interface{}{
+		"template_name":  templateName,
+		"total_versions": len(versions),
+		"current_version": versions[len(versions)-1].Version,
+		"oldest_version":  versions[0].Version,
+		"newest_version":  versions[len(versions)-1].Version,
+		"first_created":   versions[0].Timestamp,
+		"last_updated":    versions[len(versions)-1].Timestamp,
+		"total_size":      func() int64 {
+			total := int64(0)
+			for _, v := range versions {
+				total += v.Size
+			}
+			return total
+		}(),
+	}
+}
+
+// GetTemplateVersionHistory returns the complete version history for a template
+func (vm *VersionManager) GetTemplateVersionHistory(templateName string) (*VersionHistory, error) {
+	versions := vm.versions[templateName]
+	if len(versions) == 0 {
+		return nil, fmt.Errorf("no versions found for template: %s", templateName)
+	}
+
+	var current VersionInfo
+	for _, v := range versions {
+		if v.Active {
+			current = v
+			break
+		}
+	}
+
+	// If no active version, use the latest
+	if current.Version == "" {
+		current = versions[len(versions)-1]
+	}
+
+	return &VersionHistory{
+		TemplateName: templateName,
+		Versions:     versions,
+		Current:      current,
+	}, nil
+}