diff --git a/src/core/webview/packageManagerMessageHandler.ts b/src/core/webview/packageManagerMessageHandler.ts
index 73056b55c4..c9522b184f 100644
--- a/src/core/webview/packageManagerMessageHandler.ts
+++ b/src/core/webview/packageManagerMessageHandler.ts
@@ -28,15 +28,11 @@ export async function handlePackageManagerMessages(
 	switch (message.type) {
 		case "webviewDidLaunch": {
 			// For webviewDidLaunch, we don't do anything - package manager items will be loaded by explicit fetchPackageManagerItems
-			console.log(
-				"Package Manager: webviewDidLaunch received, but skipping fetch (will be triggered by explicit fetchPackageManagerItems)",
-			)
 			return true
 		}
 		case "fetchPackageManagerItems": {
 			// Prevent multiple simultaneous fetches
 			if (packageManagerManager.isFetching) {
-				console.log("Package Manager: Fetch already in progress, skipping")
 				await provider.postMessageToWebview({
 					type: "state",
 					text: "Fetch already in progress",
@@ -47,10 +43,7 @@ export async function handlePackageManagerMessages(
 
 			// Check if we need to force refresh using type assertion
 			const forceRefresh = (message as any).forceRefresh === true
-			console.log(`Package Manager: Fetch requested with forceRefresh=${forceRefresh}`)
 			try {
-				console.log("Package Manager: Received request to fetch package manager items")
-				console.log("DEBUG: Processing package manager request")
 				packageManagerManager.isFetching = true
 
 				// Wrap the entire initialization in a try-catch block
@@ -61,26 +54,19 @@ export async function handlePackageManagerMessages(
 						[]
 
 					if (!sources || sources.length === 0) {
-						console.log("Package Manager: No sources found, initializing default sources")
 						sources = [DEFAULT_PACKAGE_MANAGER_SOURCE]
 
 						// Save the default sources
 						await provider.contextProxy.setValue("packageManagerSources", sources)
-						console.log("Package Manager: Default sources initialized")
 					}
 
-					console.log(`Package Manager: Fetching items from ${sources.length} sources`)
-					console.log(`DEBUG: PackageManagerManager instance: ${packageManagerManager ? "exists" : "null"}`)
-
 					// Add timing information
 					const startTime = Date.now()
 
 					// Fetch items from all enabled sources
-					console.log("DEBUG: Starting to fetch items from sources")
 					const enabledSources = sources.filter((s) => s.enabled)
 
 					if (enabledSources.length === 0) {
-						console.log("DEBUG: No enabled sources found")
 						vscode.window.showInformationMessage(
 							"No enabled sources configured. Add and enable sources to view items.",
 						)
@@ -88,7 +74,6 @@ export async function handlePackageManagerMessages(
 						return true
 					}
 
-					console.log(`Package Manager: Fetching items from ${enabledSources.length} sources`)
 					const result = await packageManagerManager.getPackageManagerItems(enabledSources)
 
 					// If there are errors but also items, show warning
@@ -108,19 +93,13 @@ export async function handlePackageManagerMessages(
 						packageManagerManager.isFetching = false
 					}
 
-					console.log("DEBUG: Successfully fetched items:", result.items.length)
-
-					console.log("DEBUG: Fetch completed, preparing to send items to webview")
 					const endTime = Date.now()
 
-					console.log(`Package Manager: Found ${result.items.length} items in ${endTime - startTime}ms`)
-					console.log(`Package Manager: First item:`, result.items.length > 0 ? result.items[0] : "No items")
 					// The items are already stored in PackageManagerManager's currentItems
 					// No need to store in global state
 
 					// Send state to webview
 					await provider.postStateToWebview()
-					console.log("Package Manager: State sent to webview")
 				} catch (initError) {
 					const errorMessage = `Package manager initialization failed: ${initError instanceof Error ? initError.message : String(initError)}`
 					console.error("Error in package manager initialization:", initError)
@@ -166,8 +145,6 @@ export async function handlePackageManagerMessages(
 
 				// Filter out invalid sources
 				if (validationErrors.length > 0) {
-					console.log("Package Manager: Validation errors found in sources", validationErrors)
-
 					// Create a map of invalid indices
 					const invalidIndices = new Set<number>()
 					validationErrors.forEach((error: ValidationError) => {
@@ -195,9 +172,7 @@ export async function handlePackageManagerMessages(
 
 				// Clean up cache directories for repositories that are no longer in the sources list
 				try {
-					console.log("Package Manager: Cleaning up cache directories for removed sources")
 					await packageManagerManager.cleanupCacheDirectories(updatedSources)
-					console.log("Package Manager: Cache cleanup completed")
 				} catch (error) {
 					console.error("Package Manager: Error during cache cleanup:", error)
 				}
@@ -209,10 +184,8 @@ export async function handlePackageManagerMessages(
 		}
 		case "openExternal": {
 			if (message.url) {
-				console.log(`Package Manager: Opening external URL: ${message.url}`)
 				try {
 					vscode.env.openExternal(vscode.Uri.parse(message.url))
-					console.log(`Package Manager: Successfully opened URL: ${message.url}`)
 				} catch (error) {
 					console.error(
 						`Package Manager: Failed to open URL: ${error instanceof Error ? error.message : String(error)}`,
@@ -228,27 +201,16 @@ export async function handlePackageManagerMessages(
 		}
 
 		case "filterPackageManagerItems": {
-			console.log("DEBUG: Handling filterPackageManagerItems message", {
-				filters: message.filters,
-				hasItems: packageManagerManager.getCurrentItems().length > 0,
-			})
 			if (message.filters) {
 				try {
 					// Get current items from the manager
 					const items = packageManagerManager.getCurrentItems()
-					console.log("DEBUG: Current items before filtering:", items.length)
-
 					// Apply filters using the manager's filtering logic
 					const filteredItems = packageManagerManager.filterItems(items, {
 						type: message.filters.type as ComponentType | undefined,
 						search: message.filters.search,
 						tags: message.filters.tags,
 					})
-					console.log("DEBUG: Filtered items:", {
-						beforeCount: items.length,
-						afterCount: filteredItems.length,
-						filters: message.filters,
-					})
 					// Get current state and merge filtered items
 					const currentState = await provider.getStateToPostToWebview()
 					await provider.postMessageToWebview({
@@ -258,8 +220,6 @@ export async function handlePackageManagerMessages(
 							packageManagerItems: filteredItems,
 						},
 					})
-					console.log("DEBUG: State update sent with filtered items:", filteredItems.length)
-					console.log("DEBUG: State update sent with filtered items:", filteredItems.length)
 				} catch (error) {
 					console.error("Package Manager: Error filtering items:", error)
 					vscode.window.showErrorMessage("Failed to filter package manager items")
@@ -271,8 +231,6 @@ export async function handlePackageManagerMessages(
 		case "refreshPackageManagerSource": {
 			if (message.url) {
 				try {
-					console.log(`Package Manager: Received request to refresh source ${message.url}`)
-
 					// Get the current sources
 					const sources =
 						((await provider.contextProxy.getValue("packageManagerSources")) as PackageManagerSource[]) ||
@@ -300,7 +258,6 @@ export async function handlePackageManagerMessages(
 							await provider.postStateToWebview()
 						} finally {
 							// Always notify the webview that the refresh is complete, even if it failed
-							console.log(`Package Manager: Sending repositoryRefreshComplete message for ${message.url}`)
 							await provider.postMessageToWebview({
 								type: "repositoryRefreshComplete",
 								url: message.url,
diff --git a/src/services/package-manager/GitFetcher.ts b/src/services/package-manager/GitFetcher.ts
index c07bd1f52e..b1c1a8cce2 100644
--- a/src/services/package-manager/GitFetcher.ts
+++ b/src/services/package-manager/GitFetcher.ts
@@ -199,7 +199,6 @@ export class GitFetcher {
 			// Get current branch
 			const git = simpleGit(repoDir)
 			const branch = await git.revparse(["--abbrev-ref", "HEAD"])
-			console.log(`Repository cloned/pulled successfully on branch ${branch}`)
 		} catch (error) {
 			throw new Error(
 				`Failed to clone/pull repository: ${error instanceof Error ? error.message : String(error)}`,
diff --git a/src/services/package-manager/MetadataScanner.ts b/src/services/package-manager/MetadataScanner.ts
index c815daa982..beb58b50bb 100644
--- a/src/services/package-manager/MetadataScanner.ts
+++ b/src/services/package-manager/MetadataScanner.ts
@@ -45,9 +45,6 @@ export class MetadataScanner {
 	): Promise<PackageManagerItem[]> {
 		const items: PackageManagerItem[] = []
 
-		console.log("scanDirectory called with rootDir:", rootDir)
-		console.log("scanDirectory called with repoUrl:", repoUrl)
-
 		// Only set originalRootDir on the first call, not recursive calls
 		if (!isRecursiveCall && !this.originalRootDir) {
 			this.originalRootDir = rootDir
@@ -60,19 +57,11 @@ export class MetadataScanner {
 				if (!entry.isDirectory()) continue
 
 				const componentDir = path.join(rootDir, entry.name)
-				console.log("scanDirectory - entry.name:", entry.name)
-				console.log("scanDirectory - rootDir:", rootDir)
-				console.log("scanDirectory - componentDir:", componentDir)
 				// Always calculate paths relative to the original root directory
 				const relativePath = path.relative(this.originalRootDir || rootDir, componentDir).replace(/\\/g, "/")
-				console.log("scanDirectory - relativePath:", relativePath)
-				console.log("Checking directory:", componentDir)
 				const metadata = await this.loadComponentMetadata(componentDir)
-				console.log("Found metadata:", metadata)
-
 				// If no metadata found, or metadata validation fails, try recursing
 				if (!metadata || !this.getLocalizedMetadata(metadata)) {
-					console.log("No valid metadata found, recursing into:", componentDir)
 					// Pass the current directory as the root for this recursive call
 					const subItems = await this.scanDirectory(componentDir, repoUrl, sourceName, true)
 					items.push(...subItems)
@@ -132,14 +121,7 @@ export class MetadataScanner {
 
 				// Recursively scan subdirectories only if not in a package
 				if (!metadata || !this.isPackageMetadata(localizedMetadata)) {
-					console.log("Recursing into directory:", componentDir)
-					console.log("Current relativePath:", relativePath)
-					console.log("Current rootDir:", rootDir)
 					const subItems = await this.scanDirectory(componentDir, repoUrl, sourceName, true)
-					console.log("Received subItems:", subItems)
-					// No need to modify paths for recursive items
-					// They are already correctly calculated relative to the original root
-					console.log("Found sub items:", subItems)
 					items.push(...subItems)
 				}
 			}
@@ -179,14 +161,8 @@ export class MetadataScanner {
 	 */
 	private async loadComponentMetadata(componentDir: string): Promise<LocalizedMetadata<ComponentMetadata> | null> {
 		const metadata: LocalizedMetadata<ComponentMetadata> = {}
-		console.log("Loading metadata from directory:", componentDir)
-
 		try {
 			const entries = await fs.readdir(componentDir, { withFileTypes: true })
-			console.log(
-				"Directory entries:",
-				entries.map((e) => e.name),
-			)
 
 			// Look for metadata.{locale}.yml files
 			for (const entry of entries) {
@@ -200,9 +176,7 @@ export class MetadataScanner {
 
 				try {
 					const content = await fs.readFile(metadataPath, "utf-8")
-					console.log("Metadata content:", content)
 					const parsed = yaml.load(content) as Record<string, any>
-					console.log("Parsed metadata:", parsed)
 
 					// Add type field if missing but has a parent directory indicating type
 					if (!parsed.type) {
@@ -255,18 +229,11 @@ export class MetadataScanner {
 		const effectiveRootDir = this.originalRootDir || rootDir
 		// Always calculate path relative to the original root directory
 		const fullPath = path.relative(effectiveRootDir, componentDir).replace(/\\/g, "/")
-		console.log("createPackageManagerItem - componentDir:", componentDir)
-		console.log("createPackageManagerItem - effectiveRootDir:", effectiveRootDir)
-		console.log("createPackageManagerItem - fullPath:", fullPath)
-		console.log("createPackageManagerItem - path parts:", fullPath.split("/"))
-
 		// Don't encode spaces in URL to match test expectations
 		const urlPath = fullPath
 			.split("/")
 			.map((part) => encodeURIComponent(part))
 			.join("/")
-		console.log("createPackageManagerItem - urlPath:", urlPath)
-
 		// Create the item with the correct path and URL
 		return {
 			name: metadata.name,
@@ -329,7 +296,6 @@ export class MetadataScanner {
 		packageItem: PackageManagerItem,
 		parentPath: string = "",
 	): Promise<void> {
-		console.log(`Scanning directory: ${packageDir}`)
 		const entries = await fs.readdir(packageDir, { withFileTypes: true })
 
 		for (const entry of entries) {
@@ -338,7 +304,6 @@ export class MetadataScanner {
 			const subPath = path.join(packageDir, entry.name)
 			// Normalize path to use forward slashes
 			const relativePath = parentPath ? `${parentPath}/${entry.name}` : entry.name
-			console.log(`Found directory: ${entry.name}, relative path: ${relativePath}`)
 
 			// Try to load metadata directly
 			const subMetadata = await this.loadComponentMetadata(subPath)
@@ -347,10 +312,7 @@ export class MetadataScanner {
 				// Get localized metadata with fallback
 				const localizedSubMetadata = this.getLocalizedMetadata(subMetadata)
 				if (localizedSubMetadata) {
-					console.log(`Metadata for ${entry.name}:`, localizedSubMetadata)
-
 					const isListed = packageItem.items?.some((i) => i.path === relativePath)
-					console.log(`${entry.name} is ${isListed ? "already listed" : "not listed"}`)
 
 					if (!isListed) {
 						const subItem = {
@@ -361,7 +323,6 @@ export class MetadataScanner {
 						}
 						packageItem.items = packageItem.items || []
 						packageItem.items.push(subItem)
-						console.log(`Added ${entry.name} to items`)
 					}
 				}
 			}
diff --git a/src/services/package-manager/PackageManagerManager.ts b/src/services/package-manager/PackageManagerManager.ts
index 0acb92ad9c..92b704bf50 100644
--- a/src/services/package-manager/PackageManagerManager.ts
+++ b/src/services/package-manager/PackageManagerManager.ts
@@ -71,34 +71,27 @@ export class PackageManagerManager {
 	async getPackageManagerItems(
 		sources: PackageManagerSource[],
 	): Promise<{ items: PackageManagerItem[]; errors?: string[] }> {
-		console.log(`PackageManagerManager: Getting items from ${sources.length} sources`)
 		const items: PackageManagerItem[] = []
 		const errors: string[] = []
 
 		// Filter enabled sources
 		const enabledSources = sources.filter((s) => s.enabled)
-		console.log(`PackageManagerManager: ${enabledSources.length} enabled sources`)
 
 		// Process sources sequentially with locking
 		for (const source of enabledSources) {
 			if (this.isSourceLocked(source.url)) {
-				console.log(`PackageManagerManager: Source ${source.url} is locked, skipping`)
 				continue
 			}
 
 			try {
 				this.lockSource(source.url)
-				console.log(`PackageManagerManager: Processing source ${source.url}`)
 
 				// Queue metadata scanning operation
 				await this.queueOperation(async () => {
 					const repo = await this.getRepositoryData(source.url, false, source.name)
 
 					if (repo.items && repo.items.length > 0) {
-						console.log(`PackageManagerManager: Found ${repo.items.length} items in ${source.url}`)
 						items.push(...repo.items)
-					} else {
-						console.log(`PackageManagerManager: No items found in ${source.url}`)
 					}
 				})
 			} catch (error) {
@@ -119,7 +112,6 @@ export class PackageManagerManager {
 			...(errors.length > 0 && { errors }),
 		}
 
-		console.log(`PackageManagerManager: Returning ${items.length} total items`)
 		return result
 	}
 
@@ -157,24 +149,13 @@ export class PackageManagerManager {
 		sourceName?: string,
 	): Promise<PackageManagerRepository> {
 		try {
-			console.log(`PackageManagerManager: Getting repository data for ${url}`)
-
 			// Check cache first (unless force refresh is requested)
 			const cached = this.cache.get(url)
 
 			if (!forceRefresh && cached && Date.now() - cached.timestamp < PackageManagerManager.CACHE_EXPIRY_MS) {
-				console.log(
-					`PackageManagerManager: Using cached data for ${url} (age: ${Date.now() - cached.timestamp}ms)`,
-				)
 				return cached.data
 			}
 
-			if (forceRefresh) {
-				console.log(`PackageManagerManager: Force refresh requested for ${url}, bypassing cache`)
-			}
-
-			console.log(`PackageManagerManager: Cache miss or expired for ${url}, fetching fresh data`)
-
 			// Fetch fresh data with timeout protection
 			const fetchPromise = this.gitFetcher.fetchRepository(url, forceRefresh, sourceName)
 
@@ -190,7 +171,6 @@ export class PackageManagerManager {
 
 			// Cache the result
 			this.cache.set(url, { data, timestamp: Date.now() })
-			console.log(`PackageManagerManager: Successfully fetched and cached data for ${url}`)
 
 			return data
 		} catch (error) {
@@ -216,12 +196,9 @@ export class PackageManagerManager {
 	 * @returns The refreshed repository data
 	 */
 	async refreshRepository(url: string, sourceName?: string): Promise<PackageManagerRepository> {
-		console.log(`PackageManagerManager: Refreshing repository ${url}`)
-
 		try {
 			// Force a refresh by bypassing the cache
 			const data = await this.getRepositoryData(url, true, sourceName)
-			console.log(`PackageManagerManager: Repository ${url} refreshed successfully`)
 			return data
 		} catch (error) {
 			console.error(`PackageManagerManager: Failed to refresh repository ${url}:`, error)
@@ -258,7 +235,6 @@ export class PackageManagerManager {
 			try {
 				await fs.stat(cacheDir)
 			} catch (error) {
-				console.log("PackageManagerManager: Cache directory doesn't exist yet, nothing to clean up")
 				return
 			}
 
@@ -266,29 +242,21 @@ export class PackageManagerManager {
 			const entries = await fs.readdir(cacheDir, { withFileTypes: true })
 			const cachedRepoDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name)
 
-			console.log(`PackageManagerManager: Found ${cachedRepoDirs.length} cached repositories`)
-
 			// Get the list of repository names from current sources
 			const currentRepoNames = currentSources.map((source) => this.getRepoNameFromUrl(source.url))
 
 			// Find directories to delete
 			const dirsToDelete = cachedRepoDirs.filter((dir) => !currentRepoNames.includes(dir))
 
-			console.log(`PackageManagerManager: Found ${dirsToDelete.length} repositories to delete`)
-
 			// Delete each directory that's no longer in the sources
 			for (const dirName of dirsToDelete) {
 				try {
 					const dirPath = path.join(cacheDir, dirName)
-					console.log(`PackageManagerManager: Deleting cache directory ${dirPath}`)
 					await fs.rm(dirPath, { recursive: true, force: true })
-					console.log(`PackageManagerManager: Successfully deleted ${dirPath}`)
 				} catch (error) {
 					console.error(`PackageManagerManager: Failed to delete directory ${dirName}:`, error)
 				}
 			}
-
-			console.log(`PackageManagerManager: Cache cleanup completed, deleted ${dirsToDelete.length} directories`)
 		} catch (error) {
 			console.error("PackageManagerManager: Error cleaning up cache directories:", error)
 		}
@@ -316,15 +284,6 @@ export class PackageManagerManager {
 		items: PackageManagerItem[],
 		filters: { type?: ComponentType; search?: string; tags?: string[] },
 	): PackageManagerItem[] {
-		console.log("DEBUG: Starting filterItems", {
-			itemCount: items.length,
-			filters: {
-				type: filters.type,
-				search: filters.search,
-				tags: filters.tags,
-			},
-		})
-
 		// Helper function to normalize text for case/whitespace-insensitive comparison
 		const normalizeText = (text: string) => text.toLowerCase().replace(/\s+/g, " ").trim()
 
@@ -340,8 +299,6 @@ export class PackageManagerManager {
 		// Create a deep clone of all items
 		const clonedItems = items.map((originalItem) => JSON.parse(JSON.stringify(originalItem)) as PackageManagerItem)
 
-		console.log("Initial items:", JSON.stringify(clonedItems))
-
 		// Apply filters
 		const filteredItems = clonedItems.filter((item) => {
 			// Check parent item matches
@@ -387,11 +344,6 @@ export class PackageManagerManager {
 			return parentMatchesAll || isPackageWithMatchingSubcomponent
 		})
 
-		console.log("Filtered items:", {
-			before: clonedItems.length,
-			after: filteredItems.length,
-			filters,
-		})
 		// Add match info to filtered items
 		return filteredItems.map((item) => {
 			// Calculate parent item matches
diff --git a/src/services/package-manager/__tests__/PackageManagerManager.test.ts b/src/services/package-manager/__tests__/PackageManagerManager.test.ts
index 32361fe764..c7af660af9 100644
--- a/src/services/package-manager/__tests__/PackageManagerManager.test.ts
+++ b/src/services/package-manager/__tests__/PackageManagerManager.test.ts
@@ -556,8 +556,6 @@ describe("PackageManagerManager", () => {
 
 		// Test 1: Search for "data validator" (lowercase)
 		const filtered1 = manager.filterItems(items, { search: "data validator" })
-		console.log("Test 1 - Search for 'data validator'")
-		console.log("Filtered items count:", filtered1.length)
 
 		// Verify we find the Data Validator component
 		expect(filtered1.length).toBeGreaterThan(0)
@@ -578,24 +576,18 @@ describe("PackageManagerManager", () => {
 
 		// Test 2: Search for "DATA VALIDATOR" (uppercase)
 		const filtered2 = manager.filterItems(items, { search: "DATA VALIDATOR" })
-		console.log("\nTest 2 - Search for 'DATA VALIDATOR'")
-		console.log("Filtered items count:", filtered2.length)
 
 		// Verify we find the Data Validator component
 		expect(filtered2.length).toBeGreaterThan(0)
 
 		// Test 3: Search for "validator" (partial match)
 		const filtered3 = manager.filterItems(items, { search: "validator" })
-		console.log("\nTest 3 - Search for 'validator'")
-		console.log("Filtered items count:", filtered3.length)
 
 		// Verify we find the Data Validator component
 		expect(filtered3.length).toBeGreaterThan(0)
 
 		// Test 4: Search for "data valid" (partial match)
 		const filtered4 = manager.filterItems(items, { search: "data valid" })
-		console.log("\nTest 4 - Search for 'data valid'")
-		console.log("Filtered items count:", filtered4.length)
 
 		// Verify we find the Data Validator component
 		expect(filtered4.length).toBeGreaterThan(0)
diff --git a/webview-ui/src/components/package-manager/PackageManagerView.tsx b/webview-ui/src/components/package-manager/PackageManagerView.tsx
index 19d0d07872..3001b00687 100644
--- a/webview-ui/src/components/package-manager/PackageManagerView.tsx
+++ b/webview-ui/src/components/package-manager/PackageManagerView.tsx
@@ -18,16 +18,6 @@ const PackageManagerView: React.FC<PackageManagerViewProps> = ({ onDone }) => {
 	const [isTagInputActive, setIsTagInputActive] = useState(false)
 
 	// Debug logging for state changes
-	useEffect(() => {
-		console.log("State updated:", {
-			allItems: state.allItems,
-			displayItems: state.displayItems,
-			itemsLength: state.allItems.length,
-			displayItemsLength: state.displayItems?.length,
-			showingEmptyState: (state.displayItems || state.allItems).length === 0,
-			filters: state.filters,
-		})
-	}, [state.allItems, state.displayItems, state.filters])
 
 	// Fetch items on mount
 	useEffect(() => {
@@ -245,23 +235,12 @@ const PackageManagerView: React.FC<PackageManagerViewProps> = ({ onDone }) => {
 							const items = state.displayItems || []
 							const isEmpty = items.length === 0
 							const isLoading = state.isFetching
-							console.log("=== Rendering PackageManagerView ===")
-							console.log("Component state:", {
-								allItems: items,
-								itemCount: items.length,
-								isEmpty,
-								isLoading,
-								activeTab: state.activeTab,
-								filters: state.filters,
-							})
-
 							// Show loading state if fetching and not filtering
 							// Only show loading state if we're fetching and not filtering
 							if (
 								isLoading &&
 								!(state.filters.type || state.filters.search || state.filters.tags.length > 0)
 							) {
-								console.log("Rendering loading state due to isFetching=true")
 								return (
 									<div className="flex flex-col items-center justify-center h-64 text-vscode-descriptionForeground">
 										<p>Loading items...</p>
@@ -271,7 +250,6 @@ const PackageManagerView: React.FC<PackageManagerViewProps> = ({ onDone }) => {
 
 							// Show empty state if no items
 							if (isEmpty) {
-								console.log("Showing empty state")
 								return (
 									<div className="flex flex-col items-center justify-center h-64 text-vscode-descriptionForeground">
 										<p>No package manager items found</p>
@@ -280,7 +258,6 @@ const PackageManagerView: React.FC<PackageManagerViewProps> = ({ onDone }) => {
 							}
 
 							// Show items view
-							console.log("Showing items view with items:", items)
 							return (
 								<div>
 									<p className="text-vscode-descriptionForeground mb-4">
diff --git a/webview-ui/src/components/package-manager/PackageManagerViewStateManager.ts b/webview-ui/src/components/package-manager/PackageManagerViewStateManager.ts
index de1c35fc68..ad9126e879 100644
--- a/webview-ui/src/components/package-manager/PackageManagerViewStateManager.ts
+++ b/webview-ui/src/components/package-manager/PackageManagerViewStateManager.ts
@@ -86,60 +86,26 @@ export class PackageManagerViewStateManager {
 	}
 
 	public getState(): ViewState {
-		console.log("getState called, returning:", this.state)
 		// Create a deep copy to ensure React sees changes
 		return JSON.parse(JSON.stringify(this.state))
 	}
 
 	private notifyStateChange(): void {
-		console.log("=== State Change Notification ===")
-		console.log("Current state:", {
-			allItems: this.state.allItems,
-			displayItems: this.state.displayItems,
-			itemsLength: this.state.allItems.length,
-			displayItemsLength: this.state.displayItems?.length,
-			isFetching: this.state.isFetching,
-			activeTab: this.state.activeTab,
-			filters: this.state.filters,
-		})
-
 		// Create a deep copy to ensure React sees changes
 		const newState = JSON.parse(JSON.stringify(this.state))
 
-		console.log("Notifying handlers with state:", {
-			allItems: newState.allItems,
-			displayItems: newState.displayItems,
-			itemsLength: newState.allItems.length,
-			displayItemsLength: newState.displayItems?.length,
-			isFetching: newState.isFetching,
-			activeTab: newState.activeTab,
-			filters: newState.filters,
-		})
-
 		this.stateChangeHandlers.forEach((handler) => {
-			console.log("Calling state change handler")
 			handler(newState)
 		})
-
-		console.log("=== End State Change Notification ===")
 	}
 
 	public async transition(transition: ViewStateTransition): Promise<void> {
-		console.log(`ViewStateManager: Processing transition ${transition.type}`)
-
 		switch (transition.type) {
 			case "FETCH_ITEMS": {
 				if (this.state.isFetching) {
-					console.log("ViewStateManager: Fetch already in progress, skipping")
 					return
 				}
 
-				console.log("=== Starting Fetch ===")
-				console.log("Before setting isFetching:", {
-					isFetching: this.state.isFetching,
-					allItems: this.state.allItems.length,
-				})
-
 				// Create a new state object to ensure React sees the change
 				const newState = {
 					...this.state,
@@ -164,19 +130,11 @@ export class PackageManagerViewStateManager {
 					bool: true,
 				} as WebviewMessage)
 
-				console.log("=== Fetch Started ===")
 				break
 			}
 
 			case "FETCH_COMPLETE": {
 				const { items } = transition.payload as TransitionPayloads["FETCH_COMPLETE"]
-				console.log("=== FETCH_COMPLETE Started ===")
-				console.log("Before state update:", {
-					isFetching: this.state.isFetching,
-					currentItems: this.state.allItems.length,
-					receivedItems: items.length,
-				})
-
 				// Clear any existing timeout
 				this.clearFetchTimeout()
 
@@ -196,14 +154,7 @@ export class PackageManagerViewStateManager {
 				// Update state and notify
 				this.state = newState
 
-				console.log("After state update:", {
-					isFetching: this.state.isFetching,
-					allItems: this.state.allItems.length,
-					firstItem: this.state.allItems[0],
-				})
-
 				this.notifyStateChange()
-				console.log("=== FETCH_COMPLETE Finished ===")
 				break
 			}
 
@@ -261,11 +212,6 @@ export class PackageManagerViewStateManager {
 
 			case "UPDATE_FILTERS": {
 				const { filters = {} } = (transition.payload as TransitionPayloads["UPDATE_FILTERS"]) || {}
-				console.log("=== UPDATE_FILTERS Started ===", {
-					currentFilters: this.state.filters,
-					newFilters: filters,
-				})
-
 				// Create new filters object, preserving existing filters unless explicitly changed
 				const updatedFilters = {
 					type: filters.type ?? this.state.filters.type,
@@ -286,7 +232,6 @@ export class PackageManagerViewStateManager {
 					filters: updatedFilters,
 				} as WebviewMessage)
 
-				console.log("=== UPDATE_FILTERS Finished ===")
 				break
 			}
 
@@ -421,30 +366,8 @@ export class PackageManagerViewStateManager {
 	}
 
 	public async handleMessage(message: any): Promise<void> {
-		console.log("=== Handling Message ===", {
-			messageType: message.type,
-			hasPackageManagerItems: !!message.state?.packageManagerItems,
-			itemsLength: message.state?.packageManagerItems?.length,
-			currentState: {
-				isFetching: this.state.isFetching,
-				itemCount: this.state.allItems.length,
-			},
-		})
-
 		// Handle state updates from extension
 		if (message.type === "state") {
-			console.log("Processing state update:", {
-				isFetching: message.state?.isFetching,
-				itemCount: message.state?.packageManagerItems?.length,
-				firstItem: message.state?.packageManagerItems?.[0],
-				sources: message.state?.sources,
-				currentState: {
-					isFetching: this.state.isFetching,
-					itemCount: this.state.allItems.length,
-					sources: this.state.sources,
-				},
-			})
-
 			// Update sources from either sources or packageManagerSources in state
 			if (message.state?.sources || message.state?.packageManagerSources) {
 				const sources = message.state.packageManagerSources || message.state.sources
@@ -453,7 +376,6 @@ export class PackageManagerViewStateManager {
 			}
 
 			if (message.state?.packageManagerItems) {
-				console.log("State includes items, transitioning to FETCH_COMPLETE")
 				void this.transition({
 					type: "FETCH_COMPLETE",
 					payload: { items: message.state.packageManagerItems },
diff --git a/webview-ui/src/components/package-manager/useStateManager.ts b/webview-ui/src/components/package-manager/useStateManager.ts
index 05bc3ff8ad..eaaf00143e 100644
--- a/webview-ui/src/components/package-manager/useStateManager.ts
+++ b/webview-ui/src/components/package-manager/useStateManager.ts
@@ -2,46 +2,16 @@ import { useState, useEffect } from "react"
 import { PackageManagerViewStateManager, ViewState } from "./PackageManagerViewStateManager"
 
 export function useStateManager() {
-	const [manager] = useState(() => {
-		console.log("=== Creating PackageManagerViewStateManager ===")
-		return new PackageManagerViewStateManager()
-	})
+	const [manager] = useState(() => new PackageManagerViewStateManager())
 
-	const [state, setState] = useState(() => {
-		const initialState = manager.getState()
-		console.log("=== Initializing State ===", {
-			allItems: initialState.allItems,
-			itemsLength: initialState.allItems.length,
-			isFetching: initialState.isFetching,
-			activeTab: initialState.activeTab,
-		})
-		return initialState
-	})
+	const [state, setState] = useState(() => manager.getState())
 
 	useEffect(() => {
-		console.log("=== Setting up state change subscription and message listener ===")
-		let updateCount = 0
-
 		const handleStateChange = (newState: ViewState) => {
-			updateCount++
-			console.log(`=== State Update #${updateCount} Received ===`, {
-				allItems: newState.allItems,
-				itemsLength: newState.allItems.length,
-				isFetching: newState.isFetching,
-				activeTab: newState.activeTab,
-				previousFetching: state.isFetching,
-				stateChanged: JSON.stringify(newState) !== JSON.stringify(state),
-			})
 			setState(newState)
 		}
 
 		const handleMessage = (event: MessageEvent) => {
-			console.log("=== Message Event Received ===", {
-				type: event.data?.type,
-				hasState: !!event.data?.state,
-				isFetching: event.data?.state?.isFetching,
-				itemCount: event.data?.state?.packageManagerItems?.length,
-			})
 			manager.handleMessage(event.data)
 		}
 
@@ -49,7 +19,6 @@ export function useStateManager() {
 		const unsubscribe = manager.onStateChange(handleStateChange)
 
 		return () => {
-			console.log(`=== Cleaning up state manager (processed ${updateCount} updates) ===`)
 			window.removeEventListener("message", handleMessage)
 			unsubscribe()
 			manager.cleanup()