refactor: remove legacy slug handling from repository storage and sync manager

Author: safwaneettih

src/storage/repositoryStorage.ts

@@ -31,67 +31,3 @@ export function decodeRepositorySlug(slug: string): string {
         throw new Error(`Failed to decode repository slug: ${error}`);
     }
 }
-
-/**
- * Check if a slug is in the legacy underscore-based format
- * Legacy slugs are lowercase and contain underscores but are not valid base64url
- * @param slug The slug to check
- * @returns True if the slug appears to be in legacy format
- */
-export function isLegacySlug(slug: string): boolean {
-    // Base64url uses alphanumeric, dash, and underscore characters
-    // Legacy slugs are lowercase with underscores from URL character replacement
-    
-    // If it successfully decodes as base64url and looks like a URL, it's not legacy
-    try {
-        const decoded = Buffer.from(slug, 'base64url').toString('utf8');
-        // Check if decoded string looks like a URL (has protocol or domain pattern)
-        if (decoded.includes('://') || decoded.match(/^[a-z0-9\-\.]+\.[a-z]{2,}/i)) {
-            return false;
-        }
-    } catch {
-        // If decoding fails, it might be legacy
-    }
-
-    // Legacy format characteristics:
-    // - All lowercase
-    // - Contains underscores (from character replacement)
-    // - May contain dots and dashes
-    // - No uppercase letters (base64url can have uppercase)
-    const hasUppercase = /[A-Z]/.test(slug);
-    const hasUnderscores = slug.includes('_');
-    const isLowercase = slug === slug.toLowerCase();
-    
-    // Legacy: lowercase with underscores and no uppercase
-    return isLowercase && hasUnderscores && !hasUppercase;
-}
-
-/**
- * Convert a legacy underscore-based slug to the original URL
- * This is a best-effort conversion and may not be 100% accurate for all cases
- * @param legacySlug The legacy underscore-based slug
- * @returns The reconstructed repository URL
- */
-export function legacySlugToUrl(legacySlug: string): string {
-    // Reverse the legacy encoding process:
-    // 1. Replace underscores with slashes
-    // 2. Add https:// prefix
-    const reconstructed = legacySlug.replace(/_/g, '/');
-    
-    // Add protocol if not present
-    if (!reconstructed.startsWith('http://') && !reconstructed.startsWith('https://')) {
-        return 'https://' + reconstructed;
-    }
-    
-    return reconstructed;
-}
-
-/**
- * Migrate a legacy slug to the new base64url format
- * @param legacySlug The legacy underscore-based slug
- * @returns The new base64url-encoded slug
- */
-export function migrateLegacySlug(legacySlug: string): string {
-    const url = legacySlugToUrl(legacySlug);
-    return encodeRepositorySlug(url);
-}

src/syncManager.ts

@@ -5,7 +5,7 @@ import { StatusBarManager, SyncStatus } from './statusBarManager';
 import { Logger } from './utils/logger';
 import { NotificationManager } from './utils/notifications';
 import { GitApiManager, GitTreeItem } from './utils/gitProvider';
-import { encodeRepositorySlug, isLegacySlug, migrateLegacySlug } from './storage/repositoryStorage';
+import { encodeRepositorySlug } from './storage/repositoryStorage';
 import { GitProviderFactory } from './utils/gitProviderFactory';
 import { FileSystemManager } from './utils/fileSystem';
 import { AzureDevOpsApiManager } from './utils/azureDevOps';
@@ -687,74 +687,12 @@ export class SyncManager {
             } else {
                 this.logger.debug('No repository storage to migrate');
             }
-            
-            // Migrate legacy underscore-based slugs to base64url format
-            await this.migrateLegacySlugs();
         } catch (error) {
             this.logger.error('Error during repository storage migration', error instanceof Error ? error : undefined);
             // Don't throw - allow extension to continue even if migration fails
         }
     }
 
-    /**
-     * Migrate legacy underscore-based repository slugs to base64url format
-     */
-    private async migrateLegacySlugs(): Promise<void> {
-        try {
-            if (!await this.fileSystem.directoryExists(this.repoStorageDir)) {
-                this.logger.debug('No repository storage directory, skipping legacy slug migration');
-                return;
-            }
-
-            const fs = require('fs').promises;
-            const entries = await fs.readdir(this.repoStorageDir, { withFileTypes: true });
-            
-            let migratedCount = 0;
-            
-            for (const entry of entries) {
-                if (!entry.isDirectory()) {
-                    continue;
-                }
-                
-                const oldSlug = entry.name;
-                
-                // Check if this is a legacy slug
-                if (!isLegacySlug(oldSlug)) {
-                    continue;
-                }
-                
-                try {
-                    // Convert to new base64url slug
-                    const newSlug = migrateLegacySlug(oldSlug);
-                    const oldPath = path.join(this.repoStorageDir, oldSlug);
-                    const newPath = path.join(this.repoStorageDir, newSlug);
-                    
-                    // Check if new path already exists (avoid overwriting)
-                    if (await this.fileSystem.directoryExists(newPath)) {
-                        this.logger.warn(`Skipping migration of ${oldSlug}: target ${newSlug} already exists`);
-                        continue;
-                    }
-                    
-                    // Rename directory
-                    await fs.rename(oldPath, newPath);
-                    migratedCount++;
-                    this.logger.info(`Migrated legacy slug: ${oldSlug} -> ${newSlug}`);
-                } catch (error) {
-                    this.logger.error(`Failed to migrate legacy slug ${oldSlug}`, error instanceof Error ? error : undefined);
-                }
-            }
-            
-            if (migratedCount > 0) {
-                this.logger.info(`Successfully migrated ${migratedCount} legacy repository slug(s) to base64url format`);
-            } else {
-                this.logger.debug('No legacy slugs found to migrate');
-            }
-        } catch (error) {
-            this.logger.error('Error during legacy slug migration', error instanceof Error ? error : undefined);
-            // Don't throw - allow extension to continue even if migration fails
-        }
-    }
-
     /**
      * Get the storage path for a specific repository
      */

src/ui/promptTreeProvider.ts

@@ -4,7 +4,7 @@ import * as fs from 'fs';
 import { ConfigManager } from '../configManager';
 import { FileSystemManager } from '../utils/fileSystem';
 import { Logger } from '../utils/logger';
-import { decodeRepositorySlug, isLegacySlug, legacySlugToUrl } from '../storage/repositoryStorage';
+import { decodeRepositorySlug } from '../storage/repositoryStorage';
 
 export interface PromptInfo {
     name: string;
@@ -610,22 +610,8 @@ export class PromptTreeDataProvider implements vscode.TreeDataProvider<PromptTre
 
     /**
      * Decode a repository URL from its encoded directory name
-     * Supports both new base64url format and legacy underscore-based format
      */
     private decodeRepositoryUrl(encodedUrl: string): string {
-        // Check if this is a legacy underscore-based slug
-        if (isLegacySlug(encodedUrl)) {
-            this.logger.debug(`Detected legacy slug format: ${encodedUrl}`);
-            return legacySlugToUrl(encodedUrl);
-        }
-        
-        // Use new base64url decoding
-        try {
-            return decodeRepositorySlug(encodedUrl);
-        } catch (error) {
-            // Fallback to legacy format if base64url decoding fails
-            this.logger.warn(`Failed to decode as base64url, falling back to legacy format: ${encodedUrl}`);
-            return legacySlugToUrl(encodedUrl);
-        }
+        return decodeRepositorySlug(encodedUrl);
     }
 }