Kanify - AI-Powered Project Management

Kanify is a modern project management application that uses AI to automatically generate epics, user stories, and tickets from simple descriptions. Built with Next.js 15, TypeScript, and Supabase.

Features

• 🤖 AI-Powered Generation: Automatically create comprehensive project structures with OpenAI
• 📋 Kanban Board: Drag-and-drop task management with real-time updates
• 👥 Team Collaboration: Role-based access control and project member management
• 📊 Analytics & Reports: Track project progress and team productivity
• 🔐 Authentication: Secure login with email/password or GitHub OAuth
• 🎨 Dark/Light Mode: Beautiful UI with Tailwind CSS and shadcn/ui
• 📱 Responsive Design: Works seamlessly on desktop and mobile devices

Tech Stack

• Frontend: Next.js 15, React 19, TypeScript
• Styling: Tailwind CSS v4, shadcn/ui
• Database: PostgreSQL with Prisma ORM
• Authentication: Supabase Auth
• AI: OpenAI API
• State Management: Zustand
• Real-time: Supabase Channels
• Analytics: PostHog
• Error Tracking: Sentry
• Payments: Stripe (optional)

Getting Started

Prerequisites

• Node.js 18+
• PostgreSQL database (via Supabase)
• Supabase account
• OpenAI API key

Installation

1. Clone the repository:

git clone https://github.com/yourusername/kanify.git
cd kanify

2. Install dependencies:

npm install

3. Set up Git hooks (for code quality):

./scripts/setup-git-hooks.sh

4. Set up environment files:

# Copy example to create development environment
cp .env.example .env.development

# For production deployment, also create:
cp .env.example .env.production

4. Configure your environment files with your credentials (see Environment Variables section)

5. Activate development environment:

npm run use:dev

6. Set up the database:

npm run db:generate
npm run db:push:dev

7. Run the development server:

npm run dev

Open http://localhost:3000 to see the application.

Environment Management

We use separate development and production databases. See ENV_WORKFLOW.md for detailed instructions on:

• Switching between environments
• Managing database connections
• Deployment workflows
• Troubleshooting

Environment Variables

Create a .env.local file with the following variables:

# Supabase
NEXT_PUBLIC_SUPABASE_URL=your_supabase_project_url
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key

# Database
DATABASE_URL=your_postgres_connection_string

# OpenAI
OPENAI_API_KEY=your_openai_api_key

# Stripe (optional)
STRIPE_SECRET_KEY=your_stripe_secret_key
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=your_stripe_publishable_key
STRIPE_WEBHOOK_SECRET=your_stripe_webhook_secret

# Sentry
NEXT_PUBLIC_SENTRY_DSN=your_sentry_dsn

# PostHog
NEXT_PUBLIC_POSTHOG_KEY=your_posthog_api_key
NEXT_PUBLIC_POSTHOG_HOST=https://us.i.posthog.com

# Application
NEXT_PUBLIC_APP_URL=http://localhost:3000

Deployment

Railway (Recommended)

The project is configured for deployment on Railway, which better supports long-running AI generation processes.

1. Set up Railway:

# Run the setup script
./scripts/setup-railway.sh

2. Add GitHub Secrets:

   • Go to your Railway project → Settings → Tokens
   • Generate a new project token
   • Add to GitHub: Settings → Secrets → Actions → New repository secret
   • Required: RAILWAY_PROJECT_TOKEN (your project token)
   • Optional: RAILWAY_SERVICE_NAME (if you have multiple services, defaults to 'kanify')

3. Deploy:

   • Push to main branch to trigger deployment
   • PRs won't deploy automatically (use manual deployment if needed)

4. Monitor:

   • Health check: https://your-app.railway.app/api/health
   • Logs: railway logs

Vercel (Disabled)

Vercel deployments are disabled due to serverless function limitations with AI generation. To re-enable:

• Remove "git": { "deploymentEnabled": false } from vercel.json

Development Commands

Environment Management

# Switch to development environment
npm run use:dev

# Switch to production environment (careful!)
npm run use:prod

# Start dev server with development database
npm run dev:dev

# Start dev server with production database (careful!)
npm run dev:prod

Development

# Start development server (uses current environment)
npm run dev

# Build for production
npm run build

# Start production server
npm start

# Lint code
npm run lint

Database Commands

# Generate Prisma client
npm run db:generate

# Push schema to development database
npm run db:push:dev

# Push schema to production database
npm run db:push:prod

# Run migrations (dev only)
npm run db:migrate

# Reset database (dev only)
npm run db:reset

Project Structure

kanify/
├── src/
│   ├── app/              # Next.js app router pages
│   ├── components/       # React components
│   ├── hooks/           # Custom React hooks
│   ├── lib/             # Utility functions and configurations
│   ├── stores/          # Zustand state stores
│   └── types/           # TypeScript type definitions
├── prisma/              # Database schema and migrations
├── public/              # Static assets
└── scripts/             # Utility scripts

Key Features Documentation

AI Generation

• Create projects by describing your idea in natural language
• Automatically generates epics with detailed descriptions
• Creates tickets with acceptance criteria from epics
• Template system for consistent project structures

Project Management

• Hierarchical structure: Projects → Epics → Tickets
• Kanban board with drag-and-drop functionality
• Real-time updates across all users
• Comments and activity tracking

User Roles

• Admin: Full system access
• Project Manager: Manage projects and assignments
• Developer: Work on assigned tickets
• Viewer: Read-only access

Deployment

Vercel (Recommended)

1. Push your code to GitHub
2. Import your repository in Vercel
3. Add environment variables in Vercel dashboard
4. Deploy

Other Platforms

The app can be deployed to any platform that supports Next.js:

• Netlify
• Railway
• AWS Amplify
• Self-hosted with Docker

Contributing

This project uses Git hooks to maintain code quality and prevent direct pushes to the main branch.

Development Workflow

1. Fork and clone the repository

git clone https://github.com/yourusername/kanify.git
cd kanify

2. Set up Git hooks (required for all contributors)

./scripts/setup-git-hooks.sh

3. Create a feature branch (direct pushes to main are blocked)

git checkout -b feature/your-feature-name

4. Make your changes and commit using Conventional Commits format:

# ✅ Good commit messages
git commit -m "feat(auth): add OAuth provider support"
git commit -m "fix(api): resolve timeout in user endpoint"
git commit -m "docs: update API documentation"

# ❌ Bad commit messages (will be rejected)
git commit -m "fixed stuff"
git commit -m "WIP"

5. Push to your feature branch

git push origin feature/your-feature-name

6. Open a Pull Request on GitHub
   • GitHub Actions will run automated tests
   • Vercel will create a preview deployment
   • Request review from maintainers

Git Hooks Protection

Our Git hooks enforce:

• 🚫 No direct pushes to main - Must use feature branches
• ✅ Code quality - ESLint and TypeScript checks before commit
• 📝 Commit standards - Conventional Commits format required

See Git Hooks Documentation for more details.

Commit Message Format

All commits must follow the Conventional Commits format:

<type>(<scope>): <subject>

Types: feat, fix, docs, style, refactor, test, chore, perf, ci, build, revert

Code Standards

• TypeScript for all new code
• ESLint rules must pass
• Tests for new features
• Documentation for API changes

License

This project is licensed under the MIT License.

Support

For support, email team@kanify.ai or open an issue on GitHub.