innoday 0.75.0b0

AI-Powered Team Orchestration Platform - Streamline product development and team collaboration with AI

InnoDay Platform

AI-powered development platform for managing tickets, boards, and repositories with Claude AI integration.

🤖 Claude Code MCP Integration

Add InnoDay directly to Claude Code — create tickets, sync boards, and query work items without leaving your editor.

claude mcp add innoday -- uvx --from innoday mcp-server-innoday

Or find it in the MCP registry: io.github.havilandsoftware/mcp-server-innoday

Available MCP tools:

Tool	What it does
get_all_work	List tickets + GitHub issues across all boards and repos
sync_linear_board	Trigger a sync for a specific Linear board
get_work_summary	Summary stats — open/closed counts, breakdown by platform

Environment variables (optional):

Variable	Default	Description
INNODAY_API_URL	http://localhost:8002	URL of your running InnoDay instance
INNODAY_ORGANIZATION_ID	(none)	Default org ID — can be passed per-tool call instead

Requires a running InnoDay instance. See Quick Start below.

📜 Licensing

InnoDay is dual-licensed to protect against unauthorized monetization while keeping the project open source:

Open Source License (AGPL v3)

• ✅ Free for open source projects
• ✅ Modifications must be shared
• ✅ Network use requires source disclosure
• 📖 Read full AGPL v3 license

Commercial License

• 💼 For proprietary/commercial use
• 🔒 No source code disclosure required
• 📧 Contact: [e-mail]
• 📄 View commercial license

Why AGPL v3? It prevents others from offering InnoDay as a paid service without contributing back, while allowing us to fund development through commercial licenses.

🚀 Quick Start

# Clone and install
git clone [e-mail]:havilandsoftware/innoday.git
cd innoday
./install.sh

# Initialize platform (new terminal)
innoday platform init  # Interactive setup wizard

See Platform Setup Guide for detailed instructions.

Manual Setup

# 1. Dependencies & database
uv sync  # Installs all dependencies including psycopg2-binary for PostgreSQL

# 2. Database setup
# For PostgreSQL (Supabase):
DATABASE_URL="postgresql://user:pass@host:port/db" uv run alembic upgrade head

# For SQLite (development):
uv run alembic upgrade head

# 3. Start API server (port 8002)
uv run python -m src.main api --port 8002 --reload

# 4. Initialize platform
PYTHONPATH=. uv run python -m src.cli.main platform init

# 5. Configure CLI (optional)
PYTHONPATH=. uv run python -m src.cli.main config init

4. Configure GitHub Integration

# Set GitHub token (get from https://github.com/settings/tokens)
export GITHUB_TOKEN="your-github-token"

# Register a GitHub repository
curl -X POST "http://localhost:8002/api/v1/organizations/{org-id}/repositories" \
  -H "Content-Type: application/json" \
  -H "x-integration-token: ${GITHUB_TOKEN}" \
  -d '{
    "name": "repo-name",
    "url": "https://github.com/owner/repo",
    "platform": "github",
    "sync_issues": true
  }'

# Sync repository issues
curl -X POST "http://localhost:8002/api/v1/organizations/{org-id}/repositories/{repo-id}/sync" \
  -H "x-integration-token: ${GITHUB_TOKEN}"

5. Configure Jira Integration (Optional)

# Configure Jira credentials
PYTHONPATH=. uv run python -m src.cli.main config integrations
# Select "jira" and enter your Jira URL, email, and API token

# Register a Jira board
PYTHONPATH=. uv run python -m src.cli.main board register --type jira \
  "https://your-domain.atlassian.net/jira/software/boards/123" \
  "Your Board Name"

# Sync board tickets
PYTHONPATH=. uv run python -m src.cli.main board sync {board-id}

6. Configure Notion Integration (Optional)

# Configure Notion credentials
# 1. Create integration at https://www.notion.so/my-integrations
# 2. Copy integration token (starts with 'secret_')
# 3. Share your database with the integration

PYTHONPATH=. uv run python -m src.cli.main config integrations
# Select "notion" and enter your integration token

# Register a Notion database
PYTHONPATH=. uv run python -m src.cli.main board register --type notion \
  "https://www.notion.so/your-database-id" \
  "Your Database Name"

# Sync database pages as tickets
PYTHONPATH=. uv run python -m src.cli.main board sync {board-id}

🎯 Quick Usage Examples:

# Service management
innoday status             # Check all services
innoday start api          # Start just the API
innoday logs agent         # View agent logs

# Ticket management  
innoday tickets list       # List all tickets
innoday tickets create "Fix login bug"
innoday tickets update 123 --status IN_PROGRESS

# AI Agent interaction
innoday agent chat "Create tasks for auth system"
innoday agent interactive  # Interactive chat mode

# Repository management (NEW)
innoday git list           # List Git registrations
innoday git sync {id}      # Sync repository issues
innoday git repo {id}      # View repository info
innoday git issues {id}    # View repository issues

🗑️ Easy Uninstall

To uninstall InnoDay:

# If you have the repository cloned:
./uninstall.sh

# Or run these commands manually:
rm -rf ~/.innoday
rm -f ~/.local/bin/innoday

# Note: Remove PATH entry from your shell config (~/.bashrc, ~/.zshrc, or ~/.profile)
# Look for: export PATH="$HOME/.local/bin:$PATH"

---

🛠️ Alternative Installation Methods

Development Setup (No Installation)

# Clone repository
git clone https://github.com/havilandsoftware/innoday.git
cd innoday

# Use the bin wrapper (no installation needed!)
./bin/innoday --version

# Configure environment (local Supabase)
cp env/.env.local.example .env.local
# Edit .env.local with your CLAUDE_API_KEY and GITHUB_TOKEN

# Start services
./bin/innoday start all

Docker Compose

git clone https://github.com/havilandsoftware/innoday.git
cd innoday
docker compose up -d

Service URLs:

• REST API: http://localhost:8002 (Docs)
• Agent API: http://localhost:9000
• Web UI: http://localhost:7860

✨ Features That Make InnoDay Special

🤖 AI-Powered Team Orchestration

• Smart Update Collection: Automatically gather and summarize team progress with AI assistance
• Intelligent Meeting Preparation: AI-driven SCRUM facilitation and meeting insights
• Optimal Workload Distribution: Machine learning-based task assignment and team balancing
• Context-Aware Information Routing: Connect people to the right information at the right time
• Claude AI Integration: Advanced conversation analysis with recency weighting and temporal patterns

📁 Project-Based Organization (NEW)

• Unified Project Structure: Organize work with goals, scope, and clear boundaries
• Scope Document Management: Version-controlled requirements with iterative refinement workflow
• Project Update Tracking: Capture clarifications, feedback, and Q&A during scoping
• Repository Layer Classification: Categorize repos by architecture (UI, API, Data, AI, Legacy)
• Primary Repository Designation: Identify the main codebase for each project
• Integrated Board Management: One board per project for ticket tracking
• Project Overview Dashboard: Complete visibility across all project components

🔗 Unified Multi-Platform Integration

• Single Source of Truth: Seamlessly manage Jira, Trello, Notion, Linear, and GitHub from one interface
• Real-Time Synchronization: Automatic bi-directional sync with intelligent duplicate detection
• Universal Ticket Model: Work with tickets from any platform using consistent APIs — including the unified GET /work endpoint
• Linear Integration: Full GraphQL sync for Linear teams, issues, workflow states, priorities, and parent relationships
• Board Registration System: Secure, token-based integration without storing credentials

🏢 Enterprise-Ready Architecture

• Organization-Based Multi-Tenancy: Complete data isolation with flexible membership roles
• Platform Organization Protection: Special administrative entity that cannot be modified or deleted
• Smart License Management: Usage-based tiers with real-time tracking and enforcement
• Role-Based Access Control: Granular permissions (MEMBER, ADMIN, OWNER, DEVELOPER, PLATFORM)

🎯 Developer Experience

• Comprehensive CLI: Rich command-line interface with secure credential storage and beautiful output
• Modern API Design: FastAPI with automatic documentation, type safety, and async support
• Three Service Architecture: Separate API, Agent, and UI services for flexible deployment
• Container Execution Support: Run AI workloads in isolated Docker environments

🏗️ API Architecture (v1)

• 144 RESTful Endpoints: Organized across 17 specialized routers
• Organization-Scoped Resources: All operations under /api/v1/organizations/{org_id}/
• Consolidated Routers: Reduced from 20+ files to 17 well-organized modules
• Unified AI Operations: All Claude/AI functionality under /api/v1/ai/
• Complete Workflows: Project management, board sync, repository tracking, and container execution

🛡️ Security & Compliance

• Token Pass-Through: Integration credentials never stored in database
• Secure Credential Management: System keyring integration for sensitive data
• Audit Trail: Complete history for synchronization, license changes, and executions
• API Protection: Platform organization endpoints restricted to authorized users

Installable Command Line Interface

• Service Management: Start, stop, restart, and monitor all InnoDay services
• Rich Terminal Output: Beautiful tables, colors, and progress indicators
• Interactive Agent: Real-time AI conversation with thread persistence
• Secure Credentials: System keyring integration for API keys
• Multiple Formats: Table, JSON, and CSV output options
• Session Management: Persistent conversation threads and configuration

📋 Prerequisites

• Python 3.11+ (Required for full functionality and type safety)
• uv package manager (Install Guide)
• Database: PostgreSQL (production) or SQLite (development)
  • PostgreSQL requires psycopg2-binary (automatically installed via uv sync)
• Integration Accounts: Jira, Trello, GitHub, Claude AI, Slack (optional)

📖 Documentation

• API v1 Workflows - Complete API workflows and examples (NEW)
• REST API Documentation - Comprehensive endpoint reference
• Agent API Documentation - AI agent interaction guide
• CLI Documentation - Command-line interface guide
• Integration Testing Guide - Complete testing setup and configuration
• Contributing Guide - Development setup and contribution guidelines
• Domain Model - Core business objects and relationships
• Version Management - Release and versioning process
• CI/CD Pipeline - Automated testing and deployment
• Installation Guide - Detailed installation methods
• Changelog - Version history and changes

🛠️ Installation & Setup

1. Environment Setup

# Install uv package manager
curl -LsSf https://astral.sh/uv/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"

# Clone repository
git clone https://github.com/havilandsoftware/innoday.git
cd innoday

# Setup virtual environment and dependencies
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
uv sync

2. Configuration

InnoDay uses per-environment .env files. The right file is selected by the ENVIRONMENT variable:

ENVIRONMENT	File loaded	Use case
local (default)	.env.local	Local Supabase (supabase start, port 54322)
dev	.env.dev	Shared Supabase cloud dev project
production	.env	Prod — vars injected by platform (Render/Railway/etc.)

# Local development (against local Supabase)
cp env/.env.local.example .env.local
# Fill in your CLAUDE_API_KEY and GITHUB_TOKEN, then:
ENVIRONMENT=local uv run python -m src.main api --port 8002

# Development (against cloud Supabase dev project)
cp env/.env.dev.example .env.dev
# Fill in DATABASE_URL from Supabase dashboard → Settings → Database
ENVIRONMENT=dev uv run python -m src.main api --port 8002

# Run the environment setup validator (checks connectivity + required vars)
PYTHONPATH=. uv run python -m src.cli.main platform validate-env

# For integration testing
cp env/.env.test.example .env.test

Required variables (all environments):

Variable	Where to get it
DATABASE_URL	Local: postgresql://innoday:innoday_pass@localhost:54322/innoday · Cloud: Supabase dashboard → Settings → Database
CLAUDE_API_KEY	Anthropic Console
GITHUB_TOKEN	GitHub Settings → Tokens · Scopes: read:org, read:user, repo
GITHUB_ORG	Your GitHub organization name (e.g. havilandsoftware)

Board credentials (Jira/Linear/Trello/Notion) belong to individual organizations and are provided at board-connect time via the API — not in env files. See config/organizations.yaml for which board type each org uses.

3. Running Services

# Use CLI for service management (recommended)
uv run innoday start all             # Start all services
uv run innoday start api             # Start API only
uv run innoday status                # Check service status

# Or run services directly
uv run python -m src.main api --reload          # REST API with auto-reload
uv run python -m src.main agent --reload        # AI Agent API with auto-reload  
uv run python -m src.main ui                    # Web Interface
uv run python -m src.main agent --cli           # Interactive CLI Agent

4. CLI Usage

# Service Management
innoday start all                    # Start all services
innoday stop api                     # Stop specific service
innoday restart agent                # Restart service
innoday status                       # Check service status
innoday logs ui                      # View service logs

# Configuration
innoday config init                  # Interactive setup
innoday config show                  # View current config
innoday config set api-url http://localhost:8002

# Agent Interaction
innoday agent chat "Help me plan the sprint"    # Send message
innoday agent chat "Continue work" --refresh    # Fresh conversation
innoday agent interactive                       # Interactive mode
innoday agent interactive --refresh             # Interactive, fresh start

# Project Management
innoday project create "Customer Portal" --description "Q1 features"
innoday project add-repo https://github.com/org/frontend --layer ui
innoday project list                 # List all projects
innoday project overview             # Show project dashboard

# Scope Management (NEW)
innoday scope create PROJECT_ID "Build e-commerce platform"
innoday scope get PROJECT_ID         # View current scope
innoday scope update PROJECT_ID SCOPE_ID --estimated-hours 320
innoday scope add-update PROJECT_ID question "What payment methods?"
innoday scope list-updates PROJECT_ID --pending-only
innoday scope finalize PROJECT_ID SCOPE_ID
innoday scope update-status PROJECT_ID active "Scope approved"

# Ticket Management
innoday tickets list                 # List all tickets
innoday tickets create "New feature" # Create ticket
innoday sync trello-board BOARD_ID   # Sync from Trello

# Authentication & Credentials  
innoday auth login                   # Setup authentication
innoday --help                       # Show all commands

🧪 Development & Testing

Running Tests

# Full test suite
uv run python -m pytest tests/ -v

# Specific test categories
uv run python -m pytest tests/test_api* -v      # API tests
uv run python -m pytest tests/test_cli* -v      # CLI tests  
uv run python -m pytest tests/test_agent* -v    # Agent tests

# Coverage report
uv run python -m pytest tests/ --cov=src --cov-report=html

Code Quality

# Format code
uv run black src/ tests/
uv run isort src/ tests/

# Lint code
uv run flake8 src/ tests/
uv run bandit -r src/

# Type checking
uv run mypy src/

🏗️ Architecture

InnoDay follows a modular architecture with clear separation of concerns:

src/
├── api/              # REST API & external integrations
├── agent/            # AI agent with HuggingFace integration
├── cli/              # Command-line interface
├── domain/           # Core business models (User, Ticket, Organization, Project)
├── middleware/       # RBAC, authentication, validation
├── routers/          # FastAPI route handlers  
├── services/         # Business logic layer (ProjectService, etc.)
├── tools/            # AI-powered automation utilities
├── ui/               # Gradio web interface
└── main.py          # Service dispatcher

Key Technologies:

• FastAPI: Modern, fast web framework with automatic API docs
• SQLModel: Type-safe ORM with Pydantic integration
• HuggingFace: AI agent capabilities and model integration
• Gradio: Interactive web interface for AI interactions
• Rich: Beautiful terminal output and CLI experience

Platform Organization

InnoDay uses a special Platform Organization that serves as the system administrator:

• Singleton Entity: Only one platform organization exists per InnoDay instance
• Special Privileges: Members with PLATFORM role have cross-organization access
• Protected Entity: Cannot be modified or deleted through standard API endpoints
• System Configuration: Holds platform-wide settings and billing information
• First-time Setup: Automatically created during innoday config init

The platform organization ensures proper system administration while maintaining security boundaries between client organizations. All system-level operations and platform management require PLATFORM role membership.

🔒 Security & Licensing

Role-Based Access Control

• Admin Users: Full system access, user management, license control
• Member Users: Standard ticket and project access
• Developer Users: Repository and project management capabilities
• Organization Isolation: Multi-tenant data separation and security

Licensing Tiers

• Pro: 1 user, 1 project, 3 tickets/day, email support
• Max: 5 users, 5 projects, unlimited tickets, priority support
• Unlimited: No restrictions, priority support

Haviland Software Clients

• Free License: Included with Haviland Software services
• Full Access: Complete platform capabilities for employees

🚢 CI/CD & Deployment

The project includes comprehensive GitHub Actions workflows:

• CI Pipeline: Tests, builds, security scans, Docker
• Version Bump & Release: Auto-bumps version on merge to main, publishes to PyPI and MCP registry, creates GitHub release
• Dependency Updates: Weekly security and package updates

Release Process (fully automated):

Every merge to main automatically:

1. Bumps the minor version in src/version.py
2. Builds and publishes the package to PyPI
3. Updates server.json version and publishes to the MCP registry
4. Creates a GitHub release with changelog

Required GitHub secrets (set once):

• PYPI_API_TOKEN — PyPI API token for the innoday package
• MCP_REGISTRY_TOKEN — JWT from mcp-publisher login github (expires ~30 days; refresh by re-running login and updating the secret)

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push to branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Development Standards:

• Python 3.11+ for type safety and performance
• Black code formatting and isort imports
• Comprehensive test coverage (pytest)
• Type hints with mypy validation
• Clear documentation and examples

📞 Support

• Documentation: API Docs | Agent API
• Issues: GitHub Issues
• Email: [e-mail]
• Enterprise: Contact for custom deployments and integrations

📄 License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) - see the LICENSE file for details.

---

Built with ❤️ by Haviland Software