Goosy - Enhance Your AI-Written Code for Production

Optimize Code. Streamline Debugging. Improve Refactoring.

Goosy is a Visual Studio Code extension designed for vibe coders to refine AI-generated and developer-written code into production-ready solutions. It offers tools for identifying vulnerabilities, analyzing complexity, intelligent refactoring with visual diff preview, smart comment removal, and comprehensive codebase-wide security scanning, ensuring your vibe coding projects are secure, maintainable, and efficient.

📚 Documentation

For complete documentation, setup guides, and deployment instructions, visit the docs/ folder:

� Quick Start - Complete setup guide
▶️ Running the Project - Development workflow
🌐 Deployment Guide - Production deployment
☁️ Vercel Deployment - Next.js authentication backend deployment
📋 Deployment Checklist - Step-by-step deployment checklist
🔧 Environment Variables - Configuration reference
🔐 Authentication Setup - GitHub OAuth integration

Goosy in Action

Goosy refining vibe coding for production

🚀 Latest Update - Version 2.9.44 (September 2025)

🔧 Critical Bug Fixes & API Stability

Fixed 422 Unprocessable Entity errors and enhanced codebase scanning reliability.

What's fixed: Complete resolution of 422 errors that prevented codebase scanning from working properly. Implemented iterative file processing to avoid overwhelming the backend API.

Key Improvements:

✅ Fixed 422 Unprocessable Entity Errors — Eliminated API errors by switching to iterative file processing
✅ Enhanced Codebase Scanning — Files now processed one-by-one with real-time results in codebase_scan.md
✅ Improved Error Handling — Better error logging and graceful failure handling
✅ Rate Limiting Protection — Built-in delays prevent API rate limiting issues

This update ensures 100% API reliability for all Goosy operations with robust environment configuration.

🚀 Quick Start

Keyboard Shortcut: Press Alt+Shift+G to scan your entire codebase
CodeLens Integration: Click "🗂️ Scan Codebase" button in any code file
Real-time Results: Watch as codebase_scan.md is populated with findings

🚫 Smart File Filtering with .goosyignore

GitIgnore-Style Syntax: Use familiar patterns like env/, *.log, node_modules/
Automatic Security Exclusions: Built-in patterns exclude sensitive files (.env, credentials)
Custom Configuration: Create .goosyignore in your workspace root
15+ Language Support: Comprehensive defaults for all major programming languages

📊 Detailed Reporting

Real-time Updates: Results appear as files are processed
Severity Breakdown: High, Medium, and Low severity vulnerability tracking
File-by-File Analysis: Individual vulnerability details with line numbers
Export Ready: Markdown format for easy sharing and documentation

⚡ Performance Optimized

Iterative Processing: Files processed one-by-one to prevent API overload
Rate Limiting Protection: Built-in delays prevent backend throttling
Progress Tracking: Real-time progress with cancellation support
Error Recovery: Graceful handling of individual file failures

📝 Usage Example

Create .goosyignore (optional):
```
env/
node_modules/
*.log
.env*
```
Run Codebase Scan:
- Press Alt+Shift+G or click "🗂️ Scan Codebase"
- Watch progress in the notification area
- View results in the automatically opened codebase_scan.md

Review Results:

# Codebase Security Scan Results

Scan Date: 9/20/2025, 2:30:00 PM
Total Files Scanned: 25
Files with Vulnerabilities: 2
Total Vulnerabilities Found: 5

## src/main.py
- **Line**: 15
- **Type**: SQL Injection
- **Severity**: High
- **Description**: Potential SQL injection vulnerability

Why Choose Goosy?

Professional-Grade Development Tools for Code Enhancement

Goosy provides comprehensive code analysis, refactoring, and code cleanup capabilities to improve your development workflow with security scanning, complexity analysis, intelligent refactoring, and comment removal.

Security Vulnerability Detection

Advanced Code Security Analysis

Advanced Threat Detection: Identifies security vulnerabilities beyond basic linting
Precise Location Mapping: Line-by-line vulnerability identification with fix suggestions
Severity Prioritization: Color-coded system (High, Medium, Low)
Minimap Integration: Quick navigation to vulnerabilities in large files
Real-Time Updates: Live vulnerability tracking during development

Comprehensive security scanning for production-ready code

Code Quality Analytics

Professional Complexity Assessment

Cyclomatic Complexity: Industry-standard complexity metrics
Maintainability Grades: A-F scoring for code maintainability assessment
Cognitive Load Analysis: Mental complexity evaluation for better code structure
Industry Standards: Established metrics for code quality measurement
Clear Reporting: Easy-to-understand quality indicators

Detailed code quality metrics for better development practices

AI-Powered Refactoring

Intelligent Code Optimization with Visual Diff Preview

Visual Diff Preview: GitHub Copilot-style green highlighting shows refactored code before acceptance
One-Click Actions: Ctrl+Enter to accept, Esc to reject changes with intuitive popup buttons
Intelligent Transformation: AI-powered code optimization while preserving functionality
Safe Changes: Real-time preview of all modifications before applying
Perfect Undo: Clean atomic operations ensure flawless undo behavior without code duplication
Code Preservation: Original code is always maintained and safely backed up

Smart refactoring with visual confidence and safety

Smart Comment Removal

Instant Code Cleanup with Multi-Language Support

One-Key Cleanup: Alt+W to safely remove all comments from selected code
Multi-Language Support: Python, JavaScript, TypeScript, Java, C++, C#, PHP, Go, Rust, Ruby, Shell, R, HTML, CSS, SQL
Smart Detection: Automatically identifies comment syntax based on file type
Code-Safe Processing: Preserves inline code while removing only comment portions
Preserve Formatting: Maintains code structure while removing comments
Output Logging: Removed comments logged to VS Code output panel for verification

Perfect for preparing code snippets for documentation or analysis

Comparison with Alternatives

Feature	Goosy (Free)	GitHub Copilot Pro ($20/month)	SonarCloud ($10/month)
Visual Diff Refactoring	✅	✅	❌
Security Vulnerability Detection	✅	❌	✅
Minimap Integration	✅	❌	❌
Code Complexity Analysis	✅	❌	✅
Smart Comment Removal	✅	❌	❌
Annual Cost	$0	$240	$120

Comprehensive features at no cost

Fair Usage Policy

10 Free Daily Requests

Goosy provides 10 free daily requests per developer with no account registration required. The usage counter resets at 00:00 UTC daily, ensuring consistent access to code analysis and refactoring features.

What's Included Daily:

10 full file security scans
10 AI-powered refactoring sessions with visual diff
10 code complexity analyses
Unlimited minimap vulnerability navigation
Support for all programming languages

Professional code analysis tools available at no cost

Getting Started

Installation

Open Visual Studio Code.
Press Ctrl+Shift+X to access the Extensions Marketplace.
Search for Goosy.
Click Install to add Goosy to your editor.

Usage

Goosy offers multiple ways to interact with its features:

Keyboard Shortcuts

Alt+G: Analyze entire file - Full security scan
Alt+Shift+G: Scan entire codebase - Comprehensive workspace-wide security analysis 🆕
Alt+S: Analyze selection - Targeted vulnerability check
Alt+R: Refactor selection - AI-powered code optimization with visual diff
Alt+C: Check complexity - Code quality metrics
Alt+W: Remove comments - Smart comment cleanup with safety
Alt+X: Clear decorations - Remove all highlights
Alt+U: Check usage - API request statistics
Ctrl+Enter: Accept refactoring (during preview)
Esc: Reject refactoring (during preview)

Codebase Scanning 🆕

Workspace-wide Analysis: Scan all code files in your project for vulnerabilities
Smart File Filtering: Automatically excludes dependencies, config files, and documentation
.goosyignore Support: Customize which files to skip (similar to .gitignore)
Comprehensive Reports: Generate detailed security reports with export options
Progress Tracking: Real-time progress with cancellation support
Batch Processing: Efficient API usage with intelligent batching

Context Menu Integration

Right-click selected code → "Goosy: Analyze Selection"
Right-click selected code → "Goosy: Remove Comments from Selection"
Right-click anywhere → "Goosy: Analyze Document"

Command Palette

Ctrl+Shift+P → Search "Goosy" for all available commands
Quick access to authentication, analysis, refactoring, and utility functions
Alt+R: Refactor with visual diff - Preview changes before applying
Alt+C: Complexity analysis - Code metrics and maintainability
Alt+W: Remove comments - Strip comments from selected code
Alt+U: Usage statistics - View remaining daily requests
Alt+L: Toggle function lenses - Smart code navigation
Alt+X: Clear decorations - Remove vulnerability highlights
Ctrl+Enter: Accept refactoring - Apply changes
Esc: Reject refactoring - Cancel changes

Command Palette

Press Ctrl+Shift+P to open the Command Palette.
Type Goosy to view available commands:
- Analyze Document/Selection: Perform a code health check.
- Check Complexity: Assess code complexity.
- Refactor Selection: Optimize selected code.
- Remove Comments from Selection: Strip comments from selected code.
- Check Usage: View remaining daily requests.

Interactive Buttons

Use the Analyze File, Check Complexity, or Refactor Selection buttons above your code.
Click the status bar for usage details.

Usage Monitoring

Track your daily usage with the status bar:

🦢 User: 8/10 left: 8 requests remaining today
🦢 Goosy: Offline: Connection issue detected
🦢 Connected: All systems operational

Tip: Click the status bar for detailed usage statistics and connection status.

Supported Languages

Goosy supports comprehensive comment removal and code analysis across 15+ programming languages:

Primary Languages

Python	JavaScript	TypeScript	C++	Java

Additional Languages

C# • PHP • Go • Rust • Ruby • Shell/Bash • R • HTML/XML • CSS • SQL

Comment Removal Features:

Hash-style comments (#) - Python, Ruby, Shell, R
C-style comments (//, /* */) - JavaScript, TypeScript, Java, C++, C#, PHP, Go, Rust
HTML comments () - HTML, XML
CSS comments (/* */) - CSS
SQL comments (--) - SQL
Smart detection - Automatically identifies comment syntax based on file extension
Docstring handling - Removes Python triple-quote docstrings (""", ''')
Block comment removal - Handles multi-line comment blocks

🚫 .goosyignore Configuration

Customize which files and directories Goosy should skip during codebase scanning with a .goosyignore file in your workspace root.

Syntax

The .goosyignore file uses patterns similar to .gitignore:

# Comments start with #

# Ignore specific files
.env
secrets.json

# Ignore file patterns
*.log
*.config.js

# Ignore directories
node_modules/
dist/
.vscode/

# Ignore patterns anywhere in the project
**/*.test.js
**/temp/**

Default Ignore Patterns

If no .goosyignore file exists, Goosy uses these default patterns:

# Environment and secrets
**/.env
**/.env.*
**/secrets.*
**/credentials.*

# Dependencies and build outputs
**/node_modules/**
**/dist/**
**/build/**
**/out/**
**/.next/**
**/target/**

# Version control and IDE
**/.git/**
**/.vscode/**
**/.idea/**

# Python environments
**/venv/**
**/env/**
**/__pycache__/**
**/*.pyc

# Configuration files
**/package.json
**/tsconfig*.json
**/*.config.js
**/*.config.ts

# Documentation and media
**/*.md
**/*.txt
**/*.png
**/*.jpg

# Test files (optional)
**/test/**
**/*.test.js
**/*.spec.ts

Pattern Examples

Pattern	Matches	Description
`.env`	`.env` in root	Exact file in workspace root
`*.log`	`app.log`, `error.log`	Files with .log extension anywhere
`logs/`	`logs/` directory	Directory named "logs" anywhere
`/temp/`	Any files in temp dirs	Files in any "temp" directory
`*/.test.js`	`src/app.test.js`	Test files anywhere in project

Benefits

🔒 Security: Prevents credential files (.env) from being sent to AI
⚡ Performance: Reduces token usage by skipping irrelevant files
🎯 Focus: Analyzes only your source code, not dependencies
📊 Accurate Reports: Cleaner vulnerability reports without noise

Usage Tips

Create .goosyignore in your workspace root directory
Test patterns using "View Ignore Patterns" in scan results
Version control your .goosyignore file for team consistency
Review defaults and customize based on your project structure

Video Demonstration

Watch Goosy in action to see how it enhances your vibe coding workflow:

About the Team

Developed by the null0x team, Goosy is the result of dedicated effort and technical expertise:


Akash	Abhinaba	Ayush	Rohit

Mentors

Our mentors provided invaluable guidance:


Narendra Nath Chatterjee	Imran Roshan	Megh Deb	Soham Banerjee	Sanglap Mridha

🛠️ Reliability & Troubleshooting

Recent Improvements (v2.9.44)

Enhanced API Reliability & Codebase Scanning: Recent updates have significantly improved system reliability and added comprehensive codebase scanning capabilities:

✅ Resolved 422 Unprocessable Entity Errors — Fixed API errors by implementing iterative file processing instead of batch processing
✅ Added Codebase Scanning — Complete workspace-wide vulnerability analysis with Alt+Shift+G shortcut
✅ Enhanced Error Handling — Better error recovery and logging for individual file failures
✅ Rate Limiting Protection — Built-in delays prevent API throttling during scanning
✅ Real-time Results — Live updates to codebase_scan.md as files are processed

Troubleshooting Common Issues

If you experience API connection issues:

Check VS Code Output Panel — Look for Goosy debug logs showing API configuration details
Verify Extension Version — Ensure you're running version 2.9.41 or later
Restart VS Code — Reload the extension to apply the latest configuration
Review Network Access — Ensure your firewall allows connections to https://akash-nath29-web--8000.prod1.defang.dev

For additional support: Visit our GitHub Issues page or check the documentation folder.

License

Goosy is licensed under the MIT License, allowing flexible use for personal and professional projects.

Acknowledgments

VS Code Team: For creating an exceptional development platform.
Beta Testers: For their feedback and support.
Community: For inspiring us to build better tools.

Thank you for choosing Goosy. We’re committed to helping you create production-ready code.