End Career Amnesia.
Automatically sync your GitHub commits, PRs, and achievements into a living resume and portfolio.

Enzo is an autonomous professional identity platform. It connects to your engineering work stream (GitHub, etc.), analyzes your contributions to find "Wins", and helps you publish them as a perfect PDF resume or a public portfolio.

• GitHub Integration: Automatically fetches commits and Pull Requests from your repositories.
• GitHub App Integration: Secure OAuth flow with automatic repository detection and permission management.
• Private Repo Support: Securely syncs work from private organizations via a GitHub App.
• Noise Filtering: Distinguishes between "Fixed typo" and "Optimized API latency by 40%".
• Portfolio Repository: Set a specific repo as your portfolio source for focused syncing.
• Real-time Sync: Automatic portfolio updates when you push code to GitHub.

• Intelligent Code Analysis: Gemini AI analyzes your codebase structure, frameworks, and technologies.
• Automatic Content Generation: Creates portfolio descriptions, project highlights, and technical summaries.
• Framework Detection: Identifies React, Next.js, Vue, Svelte, Node.js, Python, and other technologies.
• Smart Updates: Updates existing portfolio content instead of overwriting, preserving customizations.
• GitHub App Permissions: Secure repository access with granular permission controls.

• Context-Aware Chat: Use "Enzo" to query your own professional history (e.g., "What did I work on last December?").
• Agentic Tools: The AI intelligently selects tools to search by date (search_by_date), repository (search_by_repo), or semantic topic (search_by_similarity).
• Resume Context: The bot has full access to your resume data (Skills, Experience, Education) to provide tailored career advice.
• Deep Search: Retrieves "Raw Activities" (commits/PRs) and "Wins" to answer complex questions about your work.
• Source Citations: Every answer cites the specific data points used.

• Kanban Workflow: Drag-and-drop workflow to move raw data into your "Highlights".
• AI Refinement: Use Gemini 2.5 Flash to rewrite raw commit logs into executive-ready bullet points and generate professional bio variations.
• Evidence Linking: Every highlight links back to the original PR or commit diff.
• GitHub Explorer: Browse repositories and generate highlights from specific repos.
• Bulk Operations: Process multiple commits and PRs simultaneously.

• Live Preview: See changes instantly as you edit.
• PDF Import: Upload existing PDF resumes and parse content automatically.
• Custom Templates:
  • PDF: Built-in professional tech layout.
  • Word (.docx): Upload your own custom Word templates using standard tags (e.g., {name}, {summary}) for pixel-perfect control.
• Section Management: Reorder Experience, Education, Schools, and Skills with drag-and-drop.
• Version Control: Save multiple "Bio Variations" to target different roles.
• Export Options: Download as PDF or Word document.

• AI-Powered Content: Generate professional overviews, strengths analysis, recommendations, and highlights from your activity history.
• Customizable Tone: Choose from professional, casual, enthusiastic, executive, or bold tones.
• Length Control: Generate short, medium, or long content as needed.
• Date Filtering: Filter activities by date range (all time, 1 year, 6 months, or custom).
• Token Estimation: See estimated token usage before generating (input + output + thinking tokens).
• Real Token Usage: Actual Gemini API costs billed to your account.
• Save to Library: Store generated content for easy reuse.
• Free Tier Limit: Free users can generate content once; upgrade to Pro for unlimited usage.

• Live Profiles: Claim your unique username (e.g., enzo.dev/p/yourname) and share your verified career history with the world.
• Verified Badges: Show off verified commits and LinkedIn activity with trust badges.
• SEO Optimized: Meta tags, Open Graph, and JSON-LD structured data for better search visibility.
• Responsive Design: Mobile-friendly portfolio layouts.

• Content Management: Save generated bios, cover letters, and highlights to your personal library for easy reuse.
• Organization: Categorize and search through your saved content.
• Version History: Track changes to your saved content over time.

• Pay-As-You-Go (PAYG): Purchase credits as needed - $2 per 1,000,000 credits.
• Token-Based Billing: 1 token = 1 credit. Charged based on actual Gemini API usage.
• Dodo Payments Integration: Secure payment processing with webhook verification.
• Credit Tracking: View your current balance and purchase more credits from the dashboard.
• Usage Transparency: See estimated token costs before AI operations and actual usage after.
• Payment Status Handling: Robust error handling for failed payments with proper user feedback.
• Timeout Protection: Automatic fallbacks prevent infinite loading states.
• Free Tier Limits: Free users get 500,000 credits and can generate content once; upgrade to Pro for unlimited usage.

• Multi-Provider Auth: GitHub, Google, and LinkedIn OAuth integration.
• Secure Sessions: NextAuth.js v5 with proper session management.
• GitHub App Security: OAuth flow with secure token management and permission scopes.
• Database Security: Connection pooling and prepared statements for SQL injection prevention.

• Integration Waitlist: Users can sign up for early access to Slack, Google Calendar, and LinkedIn activity syncing directly from the dashboard.
• Direct Database Persistence: Robust state management ensures your beta status is saved instantly.

• Node.js 18+
• PostgreSQL Database
• GitHub OAuth App credentials
• GitHub App credentials (for portfolio automation)
• Google Gemini API Key
• Dodo Payments API Key (for credit purchases)

1. Clone the repository:

   git clone https://github.com/HectorGitt/enzo.git
   cd enzo

2. Install dependencies:

   npm install

3. Environment Setup: Create a .env.local file with the following:

   # Authentication
   GITHUB_ID=your_github_oauth_id
   GITHUB_SECRET=your_github_oauth_secret
   NEXTAUTH_SECRET=your_nextauth_secret
   NEXTAUTH_URL=http://localhost:3000
   
   # GitHub App (for portfolio automation)
   GITHUB_APP_ID=your_github_app_id
   GITHUB_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nyour_private_key_here\n-----END RSA PRIVATE KEY-----"
   
   # Database
   # Note: Use Transaction Pooler (port 6543) with ?pgbouncer=true for best performance
   DATABASE_URL="postgresql://user:password@host:6543/database?pgbouncer=true"
   
   # AI
   GEMINI_API_KEY=your_gemini_api_key
   
   # Payments (Dodo Payments)
   DODO_PAYMENTS_API_KEY=your_dodo_api_key
   DODO_PAYMENTS_WEBHOOK_KEY=your_dodo_webhook_key
   DODO_PAYMENTS_PRODUCT_ID=your_payg_product_id
   DODO_PAYMENTS_MODE=test_mode # or live_mode
   
   # SMTP (For Feedback)
   SMTP_HOST=your_smtp_host
   SMTP_PORT=465
   SMTP_USER=your_smtp_user
   SMTP_PASS=your_smtp_password
   SMTP_FROM=your_support_email
   
   # Optional: Additional OAuth providers
   GOOGLE_CLIENT_ID=your_google_client_id
   GOOGLE_CLIENT_SECRET=your_google_client_secret
   LINKEDIN_CLIENT_ID=your_linkedin_client_id
   LINKEDIN_CLIENT_SECRET=your_linkedin_client_secret

4. Database Setup:

   # Run the consolidated migration script
   npx tsx scripts/migrate.ts

5. Start the development server:

   npm run dev

6. Open the App: Navigate to http://localhost:3000.

Enzo uses a token-based credit system for AI features:

• Input Tokens: ~1 token per 3 characters
• Output Tokens: 500-2500 based on length setting
• Thinking Tokens: ~60% of input tokens (Gemini reasoning)
• Buffer: +10% safety margin

• $2 = 1,000,000 credits
• New users start with 500,000 free credits
• Minimum purchase: $10 (5M credits)

Transparent billing based on actual API usage.

For automatic portfolio updates:

1. Create a GitHub App in your GitHub settings
2. Set permissions:
   • Repository contents: Read
   • Repository metadata: Read
   • Webhooks: Read & Write
3. Configure webhook URL: https://yourdomain.com/api/github-app/callback
4. Install the app on your repositories
5. Add credentials to your .env.local file

• Automatic Repository Detection: No manual repo entry required
• Secure OAuth Flow: Proper permission management
• Real-time Updates: Portfolio updates on GitHub pushes
• Framework Analysis: AI detects tech stack and generates content

Enzo supports custom .docx templates. To create one:

1. Open Word.
2. Use the following tags (curly braces):
   • {name}, {title}, {email}, {phone}, {location}
   • {summary}
   • {skills}
   • Experience Loop:

     {#experience}
     {title} at {company}
     {description}
     {/experience}
     

3. Upload it in the Resume Builder > Templates panel.

For credit purchases to work in production:

1. Configure webhook URL in Dodo dashboard: https://yourdomain.com/api/webhooks/dodo
2. Set the webhook signing key in DODO_PAYMENTS_WEBHOOK_KEY
3. Events handled:
   • payment.succeeded - Credits added to user account
   • payment.failed - Logged for debugging
   • refund.succeeded / refund.failed - Credit adjustments

• Framework: Next.js 16 (App Router, Turbopack)
• Language: TypeScript
• Database: PostgreSQL (raw SQL via pg with connection pooling)
• Authentication: NextAuth.js v5 (GitHub, Google, LinkedIn OAuth)
• AI: Google Gemini 2.5 Flash with real token usage tracking
• Payments: Dodo Payments SDK with webhook verification
• Styling: Tailwind CSS
• PDF Generation: React-PDF with custom components
• Word Export: docxtemplater
• GitHub Integration: @octokit/rest with GitHub Apps
• State Management: React hooks with optimistic updates
• Error Handling: Comprehensive error boundaries and fallbacks

Key tables:

• UserProfile: User accounts, settings, and GitHub installations
• UserWins: GitHub activity, commits, and achievements
• CreditTransactions: Payment and usage tracking
• SavedContent: User-generated content library
• GitHubInstallations: GitHub App installations and permissions

• Connection Pooling: Efficient PostgreSQL connection management
• Prepared Statements: SQL injection prevention
• Transaction Support: Atomic operations for credit management
• Migration Scripts: Automated database setup and updates

This project is in Open Beta. Issues and PRs are welcome!

• Use TypeScript for all new code
• Follow Next.js App Router conventions
• Add proper error handling and loading states
• Test database operations thoroughly
• Use the established credit system for AI features
• Implement proper authentication checks
• Add comprehensive logging for debugging
• Follow the existing code patterns and architecture

• TypeScript Strict Mode: Enabled for type safety
• ESLint: Configured for code consistency
• Prettier: Code formatting standards
• Error Boundaries: Comprehensive error handling
• Loading States: Proper UX for async operations

MIT