diff --git a/.env.example b/.env.example
deleted file mode 100644
index 5a8aa25..0000000
--- a/.env.example
+++ /dev/null
@@ -1,19 +0,0 @@
-# Database
-DATABASE_URL=sqlite+aiosqlite:///./data/tracker.db
-
-# API Configuration
-API_HOST=0.0.0.0
-API_PORT=8000
-DEBUG=true
-
-# Security (generate with: openssl rand -hex 32)
-SECRET_KEY=your-secret-key-here
-ACCESS_TOKEN_EXPIRE_MINUTES=30
-
-# Analytics
-ENABLE_ANALYTICS=true
-ANALYTICS_BATCH_SIZE=1000
-
-# Logging
-LOG_LEVEL=INFO
-LOG_FILE=tracker.log
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 1f63185..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,87 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-
-# Virtual environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# IDEs
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-
-# Project specific
-/data/
-*.db
-*.db-*
-*.log
-/tmp/
-.coverage.*
-htmlcov/
-
-# Environment files
-.env.local
-.env.production
-
-# Claude Code session tracking
-/tmp/claude-session-id
\ No newline at end of file
diff --git a/IMPLEMENTATION_SUMMARY.md b/IMPLEMENTATION_SUMMARY.md
deleted file mode 100644
index 1fed523..0000000
--- a/IMPLEMENTATION_SUMMARY.md
+++ /dev/null
@@ -1,239 +0,0 @@
-# Claude Code Project Tracker - Implementation Summary
-
-## Overview
-
-We've successfully built a comprehensive development intelligence system that tracks your Claude Code sessions and provides detailed insights into your coding patterns, productivity, and learning journey.
-
-## What We've Built
-
-### ποΈ Architecture Components
-
-1. **FastAPI Backend** (`main.py`)
- - RESTful API with full CRUD operations
- - Async/await support for better performance
- - Automatic OpenAPI documentation at `/docs`
- - Health check endpoint
-
-2. **Database Layer** (`app/models/`, `app/database/`)
- - SQLAlchemy with async support
- - Six main entities: Projects, Sessions, Conversations, Activities, WaitingPeriods, GitOperations
- - Comprehensive relationships and computed properties
- - SQLite for local storage
-
-3. **API Endpoints** (`app/api/`)
- - **Sessions**: Start/end development sessions
- - **Conversations**: Track dialogue with Claude
- - **Activities**: Record tool usage and file operations
- - **Waiting**: Monitor think times and engagement
- - **Git**: Track repository operations
- - **Projects**: Manage and query project data
- - **Analytics**: Advanced productivity insights
-
-4. **Web Dashboard** (`app/dashboard/`)
- - Modern Bootstrap-based interface
- - Real-time charts and metrics
- - Project overview and timeline views
- - Conversation search functionality
- - Analytics and insights visualization
-
-5. **Hook Integration** (`config/claude-hooks.json`)
- - Complete hook configuration for Claude Code
- - Automatic session tracking
- - Real-time data capture
- - Dynamic session ID management
-
-### π§ͺ Testing Infrastructure
-
-- **Comprehensive test suite** with pytest
-- **Database fixtures** for realistic test scenarios
-- **API integration tests** covering all endpoints
-- **Hook simulation tests** for validation
-- **Sample data generators** for development
-
-### π Documentation
-
-- **Complete API specification** (OpenAPI/Swagger)
-- **Database schema documentation** with ERD
-- **Hook setup guide** with examples
-- **Development guide** for contributors
-- **Architecture overview** in README
-
-## Key Features
-
-### π Analytics & Insights
-
-- **Productivity Metrics**: Engagement scores, session analytics, think time analysis
-- **Development Patterns**: Working hours, tool usage, problem-solving approaches
-- **Learning Insights**: Topic frequency, skill development, complexity progression
-- **Git Intelligence**: Commit patterns, change analysis, repository health
-
-### π» Real-time Tracking
-
-- **Session Management**: Automatic start/stop with context capture
-- **Conversation Logging**: Full dialogue history with tool correlation
-- **Activity Monitoring**: Every tool use, file operation, and command execution
-- **Engagement Analysis**: Think times, flow states, productivity scoring
-
-### π Advanced Search
-
-- **Semantic Conversation Search**: Find discussions by meaning, not just keywords
-- **Project Filtering**: Focus on specific codebases
-- **Timeline Views**: Chronological development history
-- **Context Preservation**: Maintain conversation threads and outcomes
-
-### π Visual Dashboard
-
-- **Interactive Charts**: Productivity trends, tool usage, engagement patterns
-- **Project Overview**: Statistics, language analysis, activity heatmaps
-- **Real-time Updates**: Auto-refresh every 5 minutes
-- **Responsive Design**: Works on desktop and mobile
-
-## Data Model
-
-### Core Entities
-
-1. **Projects** - Development projects with metadata
-2. **Sessions** - Individual development sessions
-3. **Conversations** - User-Claude dialogue exchanges
-4. **Activities** - Tool usage and file operations
-5. **WaitingPeriods** - Think time and engagement tracking
-6. **GitOperations** - Version control activity
-
-### Key Relationships
-
-- Projects contain multiple Sessions
-- Sessions have Conversations, Activities, WaitingPeriods, and GitOperations
-- Activities can be linked to specific Conversations
-- Comprehensive foreign key relationships maintain data integrity
-
-## Getting Started
-
-### 1. Installation
-
-```bash
-# Install dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-
-# Initialize database
-python -m app.database.init_db
-
-# Start server
-python main.py
-```
-
-### 2. Hook Setup
-
-```bash
-# Copy hook configuration to Claude Code
-cp config/claude-hooks.json ~/.config/claude-code/settings.json
-```
-
-### 3. Access Dashboard
-
-- **Web Interface**: http://localhost:8000
-- **API Documentation**: http://localhost:8000/docs
-- **Health Check**: http://localhost:8000/health
-
-## File Structure
-
-```
-claude-tracker/
-βββ main.py # FastAPI application
-βββ requirements.txt # Dependencies
-βββ .env # Configuration
-βββ app/
-β βββ models/ # Database models
-β βββ api/ # REST endpoints
-β βββ database/ # DB connection & init
-β βββ dashboard/ # Web interface
-βββ tests/ # Comprehensive test suite
-βββ docs/ # Technical documentation
-βββ config/ # Hook configuration
-βββ data/ # SQLite database (created at runtime)
-```
-
-## API Endpoints Summary
-
-| Endpoint | Method | Purpose |
-|----------|---------|---------|
-| `/api/session/start` | POST | Begin development session |
-| `/api/session/end` | POST | End development session |
-| `/api/conversation` | POST | Log dialogue exchange |
-| `/api/activity` | POST | Record tool usage |
-| `/api/waiting/start` | POST | Begin waiting period |
-| `/api/waiting/end` | POST | End waiting period |
-| `/api/git` | POST | Record git operation |
-| `/api/projects` | GET | List all projects |
-| `/api/projects/{id}/timeline` | GET | Project development timeline |
-| `/api/analytics/productivity` | GET | Productivity metrics |
-| `/api/analytics/patterns` | GET | Development patterns |
-| `/api/conversations/search` | GET | Search conversation history |
-
-## Testing
-
-```bash
-# Run all tests
-pytest
-
-# Run with coverage
-pytest --cov=app --cov-report=html
-
-# Run specific test categories
-pytest -m api # API tests
-pytest -m integration # Integration tests
-pytest -m hooks # Hook simulation tests
-```
-
-## Analytics Capabilities
-
-### Productivity Intelligence
-- Engagement scoring based on response patterns
-- Session quality assessment
-- Tool efficiency analysis
-- Time allocation insights
-
-### Learning Analytics
-- Topic frequency and progression
-- Skill development velocity
-- Question complexity evolution
-- Knowledge retention patterns
-
-### Development Intelligence
-- Code change patterns
-- Problem-solving approaches
-- Workflow optimization opportunities
-- Cross-project learning transfer
-
-## Privacy & Security
-
-- **Local Storage**: All data remains on your machine
-- **No External Dependencies**: No cloud services required
-- **Full Data Ownership**: Complete control over your development history
-- **Configurable Tracking**: Enable/disable features per project
-
-## Future Enhancements
-
-The system is designed for extensibility:
-
-- **Export Capabilities**: JSON, CSV, and report generation
-- **Advanced Visualizations**: 3D charts, network graphs, heat maps
-- **Machine Learning**: Predictive productivity modeling
-- **Integration**: IDE plugins, CI/CD pipeline hooks
-- **Collaboration**: Team analytics and shared insights
-
-## Success Metrics
-
-This implementation provides:
-
-1. **Complete Development History**: Every interaction tracked and searchable
-2. **Actionable Insights**: Data-driven productivity improvements
-3. **Learning Acceleration**: Pattern recognition for skill development
-4. **Workflow Optimization**: Identify and eliminate inefficiencies
-5. **Knowledge Retention**: Preserve problem-solving approaches and solutions
-
-## Conclusion
-
-The Claude Code Project Tracker transforms your development process into a rich source of insights and intelligence. By automatically capturing every aspect of your coding journey, it provides unprecedented visibility into how you work, learn, and grow as a developer.
-
-The system is production-ready, thoroughly tested, and designed to scale with your development needs while maintaining complete privacy and control over your data.
\ No newline at end of file
diff --git a/README.md b/README.md
index 891e496..70ed270 100644
--- a/README.md
+++ b/README.md
@@ -1,146 +1,3 @@
-# Claude Code Project Tracker
+# claude-code-tracker
-A comprehensive development intelligence system that tracks your Claude Code sessions, providing insights into your coding patterns, productivity, and learning journey.
-
-## Overview
-
-The Claude Code Project Tracker automatically captures your development workflow through Claude Code's hook system, creating a detailed record of:
-
-- **Development Sessions** - When you start/stop working, what projects you focus on
-- **Conversations** - Full dialogue history with Claude for context and learning analysis
-- **Code Changes** - File modifications, tool usage, and command executions
-- **Thinking Patterns** - Wait times between interactions to understand your workflow
-- **Git Activity** - Repository changes, commits, and branch operations
-- **Productivity Metrics** - Engagement levels, output quality, and learning velocity
-
-## Architecture
-
-```
-βββββββββββββββββββ βββββββββββββββββββ βββββββββββββββββββ
-β Claude Code βββββΆβ Hook System βββββΆβ FastAPI Server β
-β (your IDE) β β β β β
-βββββββββββββββββββ βββββββββββββββββββ βββββββββββββββββββ
- β
- βΌ
-βββββββββββββββββββ βββββββββββββββββββ βββββββββββββββββββ
-β Web Dashboard ββββββ Analytics ββββββ SQLite Database β
-β β β Engine β β β
-βββββββββββββββββββ βββββββββββββββββββ βββββββββββββββββββ
-```
-
-### Components
-
-- **FastAPI Server**: REST API that receives hook data and serves analytics
-- **SQLite Database**: Local storage for all tracking data
-- **Hook Integration**: Claude Code hooks that capture development events
-- **Analytics Engine**: Processes raw data into meaningful insights
-- **Web Dashboard**: Interactive interface for exploring your development patterns
-
-## Key Features
-
-### π― Session Tracking
-- Automatic project detection and session management
-- Working directory and git branch context
-- Session duration and engagement analysis
-
-### π¬ Conversation Intelligence
-- Full dialogue history with semantic search
-- Problem-solving pattern recognition
-- Learning topic identification and progress tracking
-
-### π Development Analytics
-- Productivity metrics and engagement scoring
-- Tool usage patterns and optimization insights
-- Cross-project learning and code reuse analysis
-
-### π Advanced Insights
-- Think time analysis and flow state detection
-- Git activity correlation with conversations
-- Skill development velocity tracking
-- Workflow optimization recommendations
-
-## Data Privacy
-
-- **Local-First**: All data stays on your machine
-- **No External Services**: No data transmission to third parties
-- **Full Control**: Complete ownership of your development history
-- **Selective Tracking**: Configurable hook activation per project
-
-## Quick Start
-
-1. **Install Dependencies**
- ```bash
- pip install -r requirements.txt
- ```
-
-2. **Start the Tracking Server**
- ```bash
- python main.py
- ```
-
-3. **Configure Claude Code Hooks**
- ```bash
- # Add hooks to your Claude Code settings
- cp config/claude-hooks.json ~/.config/claude-code/
- ```
-
-4. **Access Dashboard**
- ```
- Open http://localhost:8000 in your browser
- ```
-
-## Project Structure
-
-```
-claude-tracker/
-βββ README.md # This file
-βββ requirements.txt # Python dependencies
-βββ main.py # FastAPI application entry point
-βββ config/ # Configuration files
-β βββ claude-hooks.json # Hook setup for Claude Code
-βββ app/ # Application code
-β βββ models/ # Database models
-β βββ api/ # API endpoints
-β βββ analytics/ # Insights engine
-β βββ dashboard/ # Web interface
-βββ tests/ # Test suite
-βββ docs/ # Detailed documentation
-βββ data/ # SQLite database location
-```
-
-## Documentation
-
-- [API Specification](docs/api-spec.yaml) - Complete endpoint documentation
-- [Database Schema](docs/database-schema.md) - Data model details
-- [Hook Setup Guide](docs/hook-setup.md) - Claude Code integration
-- [Development Guide](docs/development.md) - Local setup and contribution
-- [Analytics Guide](docs/analytics.md) - Understanding insights and metrics
-
-## Development
-
-See [Development Guide](docs/development.md) for detailed setup instructions.
-
-```bash
-# Install development dependencies
-pip install -r requirements-dev.txt
-
-# Run tests
-pytest
-
-# Start development server with hot reload
-uvicorn main:app --reload
-
-# Generate API documentation
-python -m app.generate_docs
-```
-
-## Contributing
-
-This project follows test-driven development. Please ensure:
-1. All new features have comprehensive tests
-2. Documentation is updated for API changes
-3. Analytics insights are validated with test data
-
-## License
-
-MIT License - See LICENSE file for details
\ No newline at end of file
+Comprehensive development intelligence system for Claude Code sessions - tracks productivity, conversations, and learning patterns
\ No newline at end of file
diff --git a/app/__init__.py b/app/__init__.py
deleted file mode 100644
index 9743e10..0000000
--- a/app/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Claude Code Project Tracker
\ No newline at end of file
diff --git a/app/api/__init__.py b/app/api/__init__.py
deleted file mode 100644
index 2f275d5..0000000
--- a/app/api/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""
-API modules for the Claude Code Project Tracker.
-"""
\ No newline at end of file
diff --git a/app/api/activities.py b/app/api/activities.py
deleted file mode 100644
index 691cb96..0000000
--- a/app/api/activities.py
+++ /dev/null
@@ -1,304 +0,0 @@
-"""
-Activity tracking API endpoints.
-"""
-
-from typing import List, Optional
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.activity import Activity
-from app.models.session import Session
-from app.api.schemas import ActivityRequest, ActivityResponse
-
-router = APIRouter()
-
-
-@router.post("/activity", response_model=ActivityResponse, status_code=status.HTTP_201_CREATED)
-async def record_activity(
- request: ActivityRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- Record a development activity (tool usage, file operation, etc.).
-
- This endpoint is called by Claude Code PostToolUse hooks.
- """
- try:
- # Verify session exists
- result = await db.execute(
- select(Session).where(Session.id == request.session_id)
- )
- session = result.scalars().first()
-
- if not session:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Session {request.session_id} not found"
- )
-
- # Create activity record
- activity = Activity(
- session_id=request.session_id,
- conversation_id=request.conversation_id,
- timestamp=request.timestamp,
- tool_name=request.tool_name,
- action=request.action,
- file_path=request.file_path,
- metadata=request.metadata,
- success=request.success,
- error_message=request.error_message,
- lines_added=request.lines_added,
- lines_removed=request.lines_removed
- )
-
- db.add(activity)
-
- # Update session activity count
- session.add_activity()
-
- # Add file to session's touched files if applicable
- if request.file_path:
- session.add_file_touched(request.file_path)
-
- await db.commit()
- await db.refresh(activity)
-
- return ActivityResponse(
- id=activity.id,
- session_id=activity.session_id,
- tool_name=activity.tool_name,
- action=activity.action,
- timestamp=activity.timestamp,
- success=activity.success
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to record activity: {str(e)}"
- )
-
-
-@router.get("/activities")
-async def get_activities(
- session_id: Optional[int] = Query(None, description="Filter by session ID"),
- tool_name: Optional[str] = Query(None, description="Filter by tool name"),
- limit: int = Query(50, description="Maximum number of results"),
- offset: int = Query(0, description="Number of results to skip"),
- db: AsyncSession = Depends(get_db)
-):
- """Get activities with optional filtering."""
- try:
- query = select(Activity).options(
- selectinload(Activity.session).selectinload(Session.project)
- )
-
- # Apply filters
- if session_id:
- query = query.where(Activity.session_id == session_id)
-
- if tool_name:
- query = query.where(Activity.tool_name == tool_name)
-
- # Order by timestamp descending
- query = query.order_by(Activity.timestamp.desc()).offset(offset).limit(limit)
-
- result = await db.execute(query)
- activities = result.scalars().all()
-
- return [
- {
- "id": activity.id,
- "session_id": activity.session_id,
- "project_name": activity.session.project.name,
- "timestamp": activity.timestamp,
- "tool_name": activity.tool_name,
- "action": activity.action,
- "file_path": activity.file_path,
- "success": activity.success,
- "programming_language": activity.get_programming_language(),
- "lines_changed": activity.total_lines_changed,
- "metadata": activity.metadata
- }
- for activity in activities
- ]
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get activities: {str(e)}"
- )
-
-
-@router.get("/activities/{activity_id}")
-async def get_activity(
- activity_id: int,
- db: AsyncSession = Depends(get_db)
-):
- """Get detailed information about a specific activity."""
- try:
- result = await db.execute(
- select(Activity)
- .options(
- selectinload(Activity.session).selectinload(Session.project),
- selectinload(Activity.conversation)
- )
- .where(Activity.id == activity_id)
- )
- activity = result.scalars().first()
-
- if not activity:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Activity {activity_id} not found"
- )
-
- return {
- "id": activity.id,
- "session_id": activity.session_id,
- "conversation_id": activity.conversation_id,
- "project_name": activity.session.project.name,
- "timestamp": activity.timestamp,
- "tool_name": activity.tool_name,
- "action": activity.action,
- "file_path": activity.file_path,
- "metadata": activity.metadata,
- "success": activity.success,
- "error_message": activity.error_message,
- "lines_added": activity.lines_added,
- "lines_removed": activity.lines_removed,
- "total_lines_changed": activity.total_lines_changed,
- "net_lines_changed": activity.net_lines_changed,
- "file_extension": activity.get_file_extension(),
- "programming_language": activity.get_programming_language(),
- "is_file_operation": activity.is_file_operation,
- "is_code_execution": activity.is_code_execution,
- "is_search_operation": activity.is_search_operation,
- "command_executed": activity.get_command_executed(),
- "search_pattern": activity.get_search_pattern(),
- "task_type": activity.get_task_type()
- }
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get activity: {str(e)}"
- )
-
-
-@router.get("/activities/stats/tools")
-async def get_tool_usage_stats(
- session_id: Optional[int] = Query(None, description="Filter by session ID"),
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to include"),
- db: AsyncSession = Depends(get_db)
-):
- """Get tool usage statistics."""
- try:
- # Base query for tool usage counts
- query = select(
- Activity.tool_name,
- func.count(Activity.id).label('usage_count'),
- func.count(func.distinct(Activity.session_id)).label('sessions_used'),
- func.avg(Activity.lines_added + Activity.lines_removed).label('avg_lines_changed'),
- func.sum(Activity.lines_added + Activity.lines_removed).label('total_lines_changed')
- ).group_by(Activity.tool_name)
-
- # Apply filters
- if session_id:
- query = query.where(Activity.session_id == session_id)
- elif project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- # Filter by date range
- if days > 0:
- from datetime import datetime, timedelta
- start_date = datetime.utcnow() - timedelta(days=days)
- query = query.where(Activity.timestamp >= start_date)
-
- result = await db.execute(query)
- stats = result.all()
-
- return [
- {
- "tool_name": stat.tool_name,
- "usage_count": stat.usage_count,
- "sessions_used": stat.sessions_used,
- "avg_lines_changed": float(stat.avg_lines_changed or 0),
- "total_lines_changed": stat.total_lines_changed or 0
- }
- for stat in stats
- ]
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get tool usage stats: {str(e)}"
- )
-
-
-@router.get("/activities/stats/languages")
-async def get_language_usage_stats(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to include"),
- db: AsyncSession = Depends(get_db)
-):
- """Get programming language usage statistics."""
- try:
- # Get activities with file operations
- query = select(Activity).where(
- Activity.file_path.isnot(None),
- Activity.tool_name.in_(["Edit", "Write", "Read"])
- )
-
- # Apply filters
- if project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- if days > 0:
- from datetime import datetime, timedelta
- start_date = datetime.utcnow() - timedelta(days=days)
- query = query.where(Activity.timestamp >= start_date)
-
- result = await db.execute(query)
- activities = result.scalars().all()
-
- # Count by programming language
- language_stats = {}
- for activity in activities:
- lang = activity.get_programming_language()
- if lang:
- if lang not in language_stats:
- language_stats[lang] = {
- "language": lang,
- "file_count": 0,
- "activity_count": 0,
- "lines_added": 0,
- "lines_removed": 0
- }
-
- language_stats[lang]["activity_count"] += 1
- language_stats[lang]["lines_added"] += activity.lines_added or 0
- language_stats[lang]["lines_removed"] += activity.lines_removed or 0
-
- # Count unique files per language
- for activity in activities:
- lang = activity.get_programming_language()
- if lang and lang in language_stats:
- # This is a rough approximation - in reality we'd need to track unique files
- language_stats[lang]["file_count"] += 1
-
- return list(language_stats.values())
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get language usage stats: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/api/analytics.py b/app/api/analytics.py
deleted file mode 100644
index 8b875bd..0000000
--- a/app/api/analytics.py
+++ /dev/null
@@ -1,483 +0,0 @@
-"""
-Analytics API endpoints for productivity insights and metrics.
-"""
-
-from typing import List, Optional, Dict, Any
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func, and_, or_
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.project import Project
-from app.models.session import Session
-from app.models.conversation import Conversation
-from app.models.activity import Activity
-from app.models.waiting_period import WaitingPeriod
-from app.models.git_operation import GitOperation
-from app.api.schemas import ProductivityMetrics
-
-router = APIRouter()
-
-
-async def calculate_engagement_score(waiting_periods: List[WaitingPeriod]) -> float:
- """Calculate overall engagement score from waiting periods."""
- if not waiting_periods:
- return 75.0 # Default neutral score
-
- scores = [wp.engagement_score for wp in waiting_periods]
- avg_score = sum(scores) / len(scores)
- return round(avg_score * 100, 1) # Convert to 0-100 scale
-
-
-async def get_productivity_trends(db: AsyncSession, sessions: List[Session], days: int) -> List[Dict[str, Any]]:
- """Calculate daily productivity trends."""
- from datetime import datetime, timedelta
-
- # Group sessions by date
- daily_data = {}
- for session in sessions:
- date_key = session.start_time.date().isoformat()
- if date_key not in daily_data:
- daily_data[date_key] = {
- "sessions": 0,
- "total_time": 0,
- "activities": 0,
- "conversations": 0
- }
-
- daily_data[date_key]["sessions"] += 1
- daily_data[date_key]["total_time"] += session.calculated_duration_minutes or 0
- daily_data[date_key]["activities"] += session.activity_count
- daily_data[date_key]["conversations"] += session.conversation_count
-
- # Calculate productivity scores (0-100 based on relative activity)
- if daily_data:
- max_activities = max(day["activities"] for day in daily_data.values()) or 1
- max_time = max(day["total_time"] for day in daily_data.values()) or 1
-
- trends = []
- for date, data in sorted(daily_data.items()):
- # Weighted score: 60% activities, 40% time
- activity_score = (data["activities"] / max_activities) * 60
- time_score = (data["total_time"] / max_time) * 40
- productivity_score = activity_score + time_score
-
- trends.append({
- "date": date,
- "score": round(productivity_score, 1)
- })
-
- return trends
-
- return []
-
-
-@router.get("/analytics/productivity", response_model=ProductivityMetrics)
-async def get_productivity_metrics(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to analyze"),
- db: AsyncSession = Depends(get_db)
-):
- """
- Get comprehensive productivity analytics and insights.
-
- Analyzes engagement, tool usage, and productivity patterns.
- """
- try:
- from datetime import datetime, timedelta
-
- # Date filter
- start_date = datetime.utcnow() - timedelta(days=days) if days > 0 else None
-
- # Base query for sessions
- session_query = select(Session).options(
- selectinload(Session.project),
- selectinload(Session.activities),
- selectinload(Session.conversations),
- selectinload(Session.waiting_periods)
- )
-
- if project_id:
- session_query = session_query.where(Session.project_id == project_id)
-
- if start_date:
- session_query = session_query.where(Session.start_time >= start_date)
-
- session_result = await db.execute(session_query)
- sessions = session_result.scalars().all()
-
- if not sessions:
- return ProductivityMetrics(
- engagement_score=0.0,
- average_session_length=0.0,
- think_time_average=0.0,
- files_per_session=0.0,
- tools_most_used=[],
- productivity_trends=[]
- )
-
- # Calculate basic metrics
- total_sessions = len(sessions)
- total_time = sum(s.calculated_duration_minutes or 0 for s in sessions)
- average_session_length = total_time / total_sessions if total_sessions > 0 else 0
-
- # Collect all waiting periods for engagement analysis
- all_waiting_periods = []
- for session in sessions:
- all_waiting_periods.extend(session.waiting_periods)
-
- # Calculate think time average
- valid_wait_times = [wp.calculated_duration_seconds for wp in all_waiting_periods
- if wp.calculated_duration_seconds is not None]
- think_time_average = sum(valid_wait_times) / len(valid_wait_times) if valid_wait_times else 0
-
- # Calculate engagement score
- engagement_score = await calculate_engagement_score(all_waiting_periods)
-
- # Calculate files per session
- total_files = sum(len(s.files_touched or []) for s in sessions)
- files_per_session = total_files / total_sessions if total_sessions > 0 else 0
-
- # Tool usage analysis
- tool_usage = {}
- for session in sessions:
- for activity in session.activities:
- tool = activity.tool_name
- if tool not in tool_usage:
- tool_usage[tool] = 0
- tool_usage[tool] += 1
-
- tools_most_used = [
- {"tool": tool, "count": count}
- for tool, count in sorted(tool_usage.items(), key=lambda x: x[1], reverse=True)[:10]
- ]
-
- # Get productivity trends
- productivity_trends = await get_productivity_trends(db, sessions, days)
-
- return ProductivityMetrics(
- engagement_score=engagement_score,
- average_session_length=round(average_session_length, 1),
- think_time_average=round(think_time_average, 1),
- files_per_session=round(files_per_session, 1),
- tools_most_used=tools_most_used,
- productivity_trends=productivity_trends
- )
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get productivity metrics: {str(e)}"
- )
-
-
-@router.get("/analytics/patterns")
-async def get_development_patterns(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to analyze"),
- db: AsyncSession = Depends(get_db)
-):
- """Analyze development patterns and workflow insights."""
- try:
- from datetime import datetime, timedelta
-
- start_date = datetime.utcnow() - timedelta(days=days) if days > 0 else None
-
- # Get sessions with related data
- session_query = select(Session).options(
- selectinload(Session.activities),
- selectinload(Session.conversations),
- selectinload(Session.waiting_periods),
- selectinload(Session.git_operations)
- )
-
- if project_id:
- session_query = session_query.where(Session.project_id == project_id)
-
- if start_date:
- session_query = session_query.where(Session.start_time >= start_date)
-
- session_result = await db.execute(session_query)
- sessions = session_result.scalars().all()
-
- if not sessions:
- return {"message": "No data available for the specified period"}
-
- # Working hours analysis
- hour_distribution = {}
- for session in sessions:
- hour = session.start_time.hour
- hour_distribution[hour] = hour_distribution.get(hour, 0) + 1
-
- # Session type patterns
- session_type_distribution = {}
- for session in sessions:
- session_type = session.session_type
- session_type_distribution[session_type] = session_type_distribution.get(session_type, 0) + 1
-
- # Git workflow patterns
- git_patterns = {"commits_per_session": 0, "commit_frequency": {}}
- total_commits = 0
- commit_days = set()
-
- for session in sessions:
- session_commits = sum(1 for op in session.git_operations if op.is_commit)
- total_commits += session_commits
-
- for op in session.git_operations:
- if op.is_commit:
- commit_days.add(op.timestamp.date())
-
- git_patterns["commits_per_session"] = round(total_commits / len(sessions), 2) if sessions else 0
- git_patterns["commit_frequency"] = round(len(commit_days) / days, 2) if days > 0 else 0
-
- # Problem-solving patterns
- problem_solving = {"debug_sessions": 0, "learning_sessions": 0, "implementation_sessions": 0}
-
- for session in sessions:
- # Analyze conversation content to infer session type
- debug_keywords = ["error", "debug", "bug", "fix", "problem", "issue"]
- learn_keywords = ["how", "what", "explain", "understand", "learn", "tutorial"]
- impl_keywords = ["implement", "create", "build", "add", "feature"]
-
- session_content = " ".join([
- conv.user_prompt or "" for conv in session.conversations
- ]).lower()
-
- if any(keyword in session_content for keyword in debug_keywords):
- problem_solving["debug_sessions"] += 1
- elif any(keyword in session_content for keyword in learn_keywords):
- problem_solving["learning_sessions"] += 1
- elif any(keyword in session_content for keyword in impl_keywords):
- problem_solving["implementation_sessions"] += 1
-
- # Tool workflow patterns
- common_sequences = {}
- for session in sessions:
- activities = sorted(session.activities, key=lambda a: a.timestamp)
- if len(activities) >= 2:
- for i in range(len(activities) - 1):
- sequence = f"{activities[i].tool_name} β {activities[i+1].tool_name}"
- common_sequences[sequence] = common_sequences.get(sequence, 0) + 1
-
- # Get top 5 tool sequences
- top_sequences = sorted(common_sequences.items(), key=lambda x: x[1], reverse=True)[:5]
-
- return {
- "analysis_period_days": days,
- "total_sessions_analyzed": len(sessions),
- "working_hours": {
- "distribution": hour_distribution,
- "peak_hours": sorted(hour_distribution.items(), key=lambda x: x[1], reverse=True)[:3],
- "most_active_hour": max(hour_distribution.items(), key=lambda x: x[1])[0] if hour_distribution else None
- },
- "session_patterns": {
- "type_distribution": session_type_distribution,
- "average_duration_minutes": round(sum(s.calculated_duration_minutes or 0 for s in sessions) / len(sessions), 1)
- },
- "git_workflow": git_patterns,
- "problem_solving_patterns": problem_solving,
- "tool_workflows": {
- "common_sequences": [{"sequence": seq, "count": count} for seq, count in top_sequences],
- "total_unique_sequences": len(common_sequences)
- }
- }
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to analyze development patterns: {str(e)}"
- )
-
-
-@router.get("/analytics/learning")
-async def get_learning_insights(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to analyze"),
- db: AsyncSession = Depends(get_db)
-):
- """Analyze learning patterns and knowledge development."""
- try:
- from datetime import datetime, timedelta
-
- start_date = datetime.utcnow() - timedelta(days=days) if days > 0 else None
-
- # Get conversations for learning analysis
- conv_query = select(Conversation).options(selectinload(Conversation.session))
-
- if project_id:
- conv_query = conv_query.join(Session).where(Session.project_id == project_id)
-
- if start_date:
- conv_query = conv_query.where(Conversation.timestamp >= start_date)
-
- conv_result = await db.execute(conv_query)
- conversations = conv_result.scalars().all()
-
- if not conversations:
- return {"message": "No conversation data available for learning analysis"}
-
- # Topic frequency analysis
- learning_keywords = {
- "authentication": ["auth", "login", "password", "token", "session"],
- "database": ["database", "sql", "query", "table", "migration"],
- "api": ["api", "rest", "endpoint", "request", "response"],
- "testing": ["test", "pytest", "unittest", "mock", "fixture"],
- "deployment": ["deploy", "docker", "aws", "server", "production"],
- "debugging": ["debug", "error", "exception", "traceback", "log"],
- "optimization": ["optimize", "performance", "speed", "memory", "cache"],
- "security": ["security", "vulnerability", "encrypt", "hash", "ssl"]
- }
-
- topic_frequency = {topic: 0 for topic in learning_keywords.keys()}
-
- for conv in conversations:
- if conv.user_prompt:
- prompt_lower = conv.user_prompt.lower()
- for topic, keywords in learning_keywords.items():
- if any(keyword in prompt_lower for keyword in keywords):
- topic_frequency[topic] += 1
-
- # Question complexity analysis
- complexity_indicators = {
- "beginner": ["how to", "what is", "how do i", "basic", "simple"],
- "intermediate": ["best practice", "optimize", "improve", "better way"],
- "advanced": ["architecture", "pattern", "scalability", "design", "system"]
- }
-
- complexity_distribution = {level: 0 for level in complexity_indicators.keys()}
-
- for conv in conversations:
- if conv.user_prompt:
- prompt_lower = conv.user_prompt.lower()
- for level, indicators in complexity_indicators.items():
- if any(indicator in prompt_lower for indicator in indicators):
- complexity_distribution[level] += 1
- break
-
- # Learning progression analysis
- weekly_topics = {}
- for conv in conversations:
- if conv.user_prompt:
- week = conv.timestamp.strftime("%Y-W%U")
- if week not in weekly_topics:
- weekly_topics[week] = set()
-
- prompt_lower = conv.user_prompt.lower()
- for topic, keywords in learning_keywords.items():
- if any(keyword in prompt_lower for keyword in keywords):
- weekly_topics[week].add(topic)
-
- # Calculate learning velocity (new topics per week)
- learning_velocity = []
- for week, topics in sorted(weekly_topics.items()):
- learning_velocity.append({
- "week": week,
- "new_topics": len(topics),
- "topics": list(topics)
- })
-
- # Repetition patterns (topics asked about multiple times)
- repeated_topics = {topic: count for topic, count in topic_frequency.items() if count > 1}
-
- return {
- "analysis_period_days": days,
- "total_conversations_analyzed": len(conversations),
- "learning_topics": {
- "frequency": topic_frequency,
- "most_discussed": max(topic_frequency.items(), key=lambda x: x[1]) if topic_frequency else None,
- "repeated_topics": repeated_topics
- },
- "question_complexity": {
- "distribution": complexity_distribution,
- "progression_indicator": "advancing" if complexity_distribution["advanced"] > complexity_distribution["beginner"] else "learning_basics"
- },
- "learning_velocity": learning_velocity,
- "insights": {
- "diverse_learning": len([t for t, c in topic_frequency.items() if c > 0]),
- "deep_dives": len(repeated_topics),
- "active_learning_weeks": len(weekly_topics),
- "avg_topics_per_week": round(sum(len(topics) for topics in weekly_topics.values()) / len(weekly_topics), 1) if weekly_topics else 0
- }
- }
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to analyze learning insights: {str(e)}"
- )
-
-
-@router.get("/analytics/summary")
-async def get_analytics_summary(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- db: AsyncSession = Depends(get_db)
-):
- """Get a high-level analytics summary dashboard."""
- try:
- # Get overall statistics
- base_query = select(Session)
- if project_id:
- base_query = base_query.where(Session.project_id == project_id)
-
- session_result = await db.execute(base_query)
- all_sessions = session_result.scalars().all()
-
- if not all_sessions:
- return {"message": "No data available"}
-
- # Basic metrics
- total_sessions = len(all_sessions)
- total_time_hours = sum(s.calculated_duration_minutes or 0 for s in all_sessions) / 60
- avg_session_minutes = (sum(s.calculated_duration_minutes or 0 for s in all_sessions) / total_sessions) if total_sessions else 0
-
- # Date range
- start_date = min(s.start_time for s in all_sessions)
- end_date = max(s.start_time for s in all_sessions)
- total_days = (end_date - start_date).days + 1
-
- # Activity summary
- total_activities = sum(s.activity_count for s in all_sessions)
- total_conversations = sum(s.conversation_count for s in all_sessions)
-
- # Recent activity (last 7 days)
- from datetime import datetime, timedelta
- week_ago = datetime.utcnow() - timedelta(days=7)
- recent_sessions = [s for s in all_sessions if s.start_time >= week_ago]
-
- # Project diversity (if not filtered by project)
- project_count = 1 if project_id else len(set(s.project_id for s in all_sessions))
-
- return {
- "overview": {
- "total_sessions": total_sessions,
- "total_time_hours": round(total_time_hours, 1),
- "average_session_minutes": round(avg_session_minutes, 1),
- "total_activities": total_activities,
- "total_conversations": total_conversations,
- "projects_tracked": project_count,
- "tracking_period_days": total_days
- },
- "recent_activity": {
- "sessions_last_7_days": len(recent_sessions),
- "time_last_7_days_hours": round(sum(s.calculated_duration_minutes or 0 for s in recent_sessions) / 60, 1),
- "daily_average_last_week": round(len(recent_sessions) / 7, 1)
- },
- "productivity_indicators": {
- "activities_per_session": round(total_activities / total_sessions, 1) if total_sessions else 0,
- "conversations_per_session": round(total_conversations / total_sessions, 1) if total_sessions else 0,
- "productivity_score": min(100, round((total_activities / total_sessions) * 5, 1)) if total_sessions else 0 # Rough scoring
- },
- "time_distribution": {
- "daily_average_hours": round(total_time_hours / total_days, 1),
- "longest_session_minutes": max(s.calculated_duration_minutes or 0 for s in all_sessions),
- "shortest_session_minutes": min(s.calculated_duration_minutes or 0 for s in all_sessions if s.calculated_duration_minutes)
- }
- }
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get analytics summary: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/api/conversations.py b/app/api/conversations.py
deleted file mode 100644
index 0df3168..0000000
--- a/app/api/conversations.py
+++ /dev/null
@@ -1,220 +0,0 @@
-"""
-Conversation tracking API endpoints.
-"""
-
-from typing import List, Optional
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, or_, func
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.conversation import Conversation
-from app.models.session import Session
-from app.api.schemas import ConversationRequest, ConversationResponse, ConversationSearchResult
-
-router = APIRouter()
-
-
-@router.post("/conversation", response_model=ConversationResponse, status_code=status.HTTP_201_CREATED)
-async def log_conversation(
- request: ConversationRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- Log a conversation exchange between user and Claude.
-
- This endpoint is called by Claude Code hooks to capture dialogue.
- """
- try:
- # Verify session exists
- result = await db.execute(
- select(Session).where(Session.id == request.session_id)
- )
- session = result.scalars().first()
-
- if not session:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Session {request.session_id} not found"
- )
-
- # Create conversation entry
- conversation = Conversation(
- session_id=request.session_id,
- timestamp=request.timestamp,
- user_prompt=request.user_prompt,
- claude_response=request.claude_response,
- tools_used=request.tools_used,
- files_affected=request.files_affected,
- context=request.context,
- tokens_input=request.tokens_input,
- tokens_output=request.tokens_output,
- exchange_type=request.exchange_type
- )
-
- db.add(conversation)
-
- # Update session conversation count
- session.add_conversation()
-
- # Add files to session's touched files list
- if request.files_affected:
- for file_path in request.files_affected:
- session.add_file_touched(file_path)
-
- await db.commit()
- await db.refresh(conversation)
-
- return ConversationResponse(
- id=conversation.id,
- session_id=conversation.session_id,
- timestamp=conversation.timestamp,
- exchange_type=conversation.exchange_type,
- content_length=conversation.content_length
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to log conversation: {str(e)}"
- )
-
-
-@router.get("/conversations/search", response_model=List[ConversationSearchResult])
-async def search_conversations(
- query: str = Query(..., description="Search query"),
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- limit: int = Query(20, description="Maximum number of results"),
- db: AsyncSession = Depends(get_db)
-):
- """
- Search through conversation history.
-
- Performs text search across user prompts and Claude responses.
- """
- try:
- # Build search query
- search_query = select(Conversation).options(
- selectinload(Conversation.session).selectinload(Session.project)
- )
-
- # Add text search conditions
- search_conditions = []
- search_terms = query.lower().split()
-
- for term in search_terms:
- term_condition = or_(
- func.lower(Conversation.user_prompt).contains(term),
- func.lower(Conversation.claude_response).contains(term)
- )
- search_conditions.append(term_condition)
-
- if search_conditions:
- search_query = search_query.where(or_(*search_conditions))
-
- # Add project filter if specified
- if project_id:
- search_query = search_query.join(Session).where(Session.project_id == project_id)
-
- # Order by timestamp descending and limit results
- search_query = search_query.order_by(Conversation.timestamp.desc()).limit(limit)
-
- result = await db.execute(search_query)
- conversations = result.scalars().all()
-
- # Build search results with relevance scoring
- results = []
- for conversation in conversations:
- # Simple relevance scoring based on term matches
- relevance_score = 0.0
- content = (conversation.user_prompt or "") + " " + (conversation.claude_response or "")
- content_lower = content.lower()
-
- for term in search_terms:
- relevance_score += content_lower.count(term) / len(search_terms)
-
- # Normalize score (rough approximation)
- relevance_score = min(relevance_score / 10, 1.0)
-
- # Extract context snippets
- context_snippets = []
- for term in search_terms:
- if term in content_lower:
- start_idx = content_lower.find(term)
- start = max(0, start_idx - 50)
- end = min(len(content), start_idx + len(term) + 50)
- snippet = content[start:end].strip()
- if snippet and snippet not in context_snippets:
- context_snippets.append(snippet)
-
- results.append(ConversationSearchResult(
- id=conversation.id,
- project_name=conversation.session.project.name,
- timestamp=conversation.timestamp,
- user_prompt=conversation.user_prompt,
- claude_response=conversation.claude_response,
- relevance_score=relevance_score,
- context=context_snippets[:3] # Limit to 3 snippets
- ))
-
- # Sort by relevance score descending
- results.sort(key=lambda x: x.relevance_score, reverse=True)
-
- return results
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to search conversations: {str(e)}"
- )
-
-
-@router.get("/conversations/{conversation_id}")
-async def get_conversation(
- conversation_id: int,
- db: AsyncSession = Depends(get_db)
-):
- """Get detailed information about a specific conversation."""
- try:
- result = await db.execute(
- select(Conversation)
- .options(selectinload(Conversation.session).selectinload(Session.project))
- .where(Conversation.id == conversation_id)
- )
- conversation = result.scalars().first()
-
- if not conversation:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Conversation {conversation_id} not found"
- )
-
- return {
- "id": conversation.id,
- "session_id": conversation.session_id,
- "project_name": conversation.session.project.name,
- "timestamp": conversation.timestamp,
- "user_prompt": conversation.user_prompt,
- "claude_response": conversation.claude_response,
- "tools_used": conversation.tools_used,
- "files_affected": conversation.files_affected,
- "context": conversation.context,
- "exchange_type": conversation.exchange_type,
- "content_length": conversation.content_length,
- "estimated_tokens": conversation.estimated_tokens,
- "intent_category": conversation.get_intent_category(),
- "complexity_level": conversation.get_complexity_level(),
- "has_file_operations": conversation.has_file_operations(),
- "has_code_execution": conversation.has_code_execution()
- }
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get conversation: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/api/git.py b/app/api/git.py
deleted file mode 100644
index c82eccb..0000000
--- a/app/api/git.py
+++ /dev/null
@@ -1,360 +0,0 @@
-"""
-Git operation tracking API endpoints.
-"""
-
-from typing import List, Optional
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.git_operation import GitOperation
-from app.models.session import Session
-from app.api.schemas import GitOperationRequest, GitOperationResponse
-
-router = APIRouter()
-
-
-@router.post("/git", response_model=GitOperationResponse, status_code=status.HTTP_201_CREATED)
-async def record_git_operation(
- request: GitOperationRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- Record a git operation performed during development.
-
- Called by hooks when git commands are executed via Bash tool.
- """
- try:
- # Verify session exists
- result = await db.execute(
- select(Session).where(Session.id == request.session_id)
- )
- session = result.scalars().first()
-
- if not session:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Session {request.session_id} not found"
- )
-
- # Create git operation record
- git_operation = GitOperation(
- session_id=request.session_id,
- timestamp=request.timestamp,
- operation=request.operation,
- command=request.command,
- result=request.result,
- success=request.success,
- files_changed=request.files_changed,
- lines_added=request.lines_added,
- lines_removed=request.lines_removed,
- commit_hash=request.commit_hash,
- branch_from=request.branch_from,
- branch_to=request.branch_to
- )
-
- db.add(git_operation)
- await db.commit()
- await db.refresh(git_operation)
-
- return GitOperationResponse(
- id=git_operation.id,
- session_id=git_operation.session_id,
- operation=git_operation.operation,
- timestamp=git_operation.timestamp,
- success=git_operation.success,
- commit_hash=git_operation.commit_hash
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to record git operation: {str(e)}"
- )
-
-
-@router.get("/git/operations")
-async def get_git_operations(
- session_id: Optional[int] = Query(None, description="Filter by session ID"),
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- operation: Optional[str] = Query(None, description="Filter by operation type"),
- limit: int = Query(50, description="Maximum number of results"),
- offset: int = Query(0, description="Number of results to skip"),
- db: AsyncSession = Depends(get_db)
-):
- """Get git operations with optional filtering."""
- try:
- query = select(GitOperation).options(
- selectinload(GitOperation.session).selectinload(Session.project)
- )
-
- # Apply filters
- if session_id:
- query = query.where(GitOperation.session_id == session_id)
- elif project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- if operation:
- query = query.where(GitOperation.operation == operation)
-
- # Order by timestamp descending
- query = query.order_by(GitOperation.timestamp.desc()).offset(offset).limit(limit)
-
- result = await db.execute(query)
- git_operations = result.scalars().all()
-
- return [
- {
- "id": op.id,
- "session_id": op.session_id,
- "project_name": op.session.project.name,
- "timestamp": op.timestamp,
- "operation": op.operation,
- "command": op.command,
- "result": op.result,
- "success": op.success,
- "files_changed": op.files_changed,
- "files_count": op.files_count,
- "lines_added": op.lines_added,
- "lines_removed": op.lines_removed,
- "total_lines_changed": op.total_lines_changed,
- "net_lines_changed": op.net_lines_changed,
- "commit_hash": op.commit_hash,
- "commit_message": op.get_commit_message(),
- "commit_category": op.get_commit_category(),
- "change_size_category": op.get_change_size_category()
- }
- for op in git_operations
- ]
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get git operations: {str(e)}"
- )
-
-
-@router.get("/git/operations/{operation_id}")
-async def get_git_operation(
- operation_id: int,
- db: AsyncSession = Depends(get_db)
-):
- """Get detailed information about a specific git operation."""
- try:
- result = await db.execute(
- select(GitOperation)
- .options(selectinload(GitOperation.session).selectinload(Session.project))
- .where(GitOperation.id == operation_id)
- )
- git_operation = result.scalars().first()
-
- if not git_operation:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Git operation {operation_id} not found"
- )
-
- return {
- "id": git_operation.id,
- "session_id": git_operation.session_id,
- "project_name": git_operation.session.project.name,
- "timestamp": git_operation.timestamp,
- "operation": git_operation.operation,
- "command": git_operation.command,
- "result": git_operation.result,
- "success": git_operation.success,
- "files_changed": git_operation.files_changed,
- "files_count": git_operation.files_count,
- "lines_added": git_operation.lines_added,
- "lines_removed": git_operation.lines_removed,
- "total_lines_changed": git_operation.total_lines_changed,
- "net_lines_changed": git_operation.net_lines_changed,
- "commit_hash": git_operation.commit_hash,
- "branch_from": git_operation.branch_from,
- "branch_to": git_operation.branch_to,
- "commit_message": git_operation.get_commit_message(),
- "branch_name": git_operation.get_branch_name(),
- "is_commit": git_operation.is_commit,
- "is_push": git_operation.is_push,
- "is_pull": git_operation.is_pull,
- "is_branch_operation": git_operation.is_branch_operation,
- "is_merge_commit": git_operation.is_merge_commit(),
- "is_feature_commit": git_operation.is_feature_commit(),
- "is_bugfix_commit": git_operation.is_bugfix_commit(),
- "is_refactor_commit": git_operation.is_refactor_commit(),
- "commit_category": git_operation.get_commit_category(),
- "change_size_category": git_operation.get_change_size_category()
- }
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get git operation: {str(e)}"
- )
-
-
-@router.get("/git/stats/commits")
-async def get_commit_stats(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to include"),
- db: AsyncSession = Depends(get_db)
-):
- """Get commit statistics and patterns."""
- try:
- # Base query for commits
- query = select(GitOperation).where(GitOperation.operation == "commit")
-
- # Apply filters
- if project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- if days > 0:
- from datetime import datetime, timedelta
- start_date = datetime.utcnow() - timedelta(days=days)
- query = query.where(GitOperation.timestamp >= start_date)
-
- result = await db.execute(query)
- commits = result.scalars().all()
-
- if not commits:
- return {
- "total_commits": 0,
- "commit_categories": {},
- "change_size_distribution": {},
- "average_lines_per_commit": 0.0,
- "commit_frequency": []
- }
-
- # Calculate statistics
- total_commits = len(commits)
-
- # Categorize commits
- categories = {}
- for commit in commits:
- category = commit.get_commit_category()
- categories[category] = categories.get(category, 0) + 1
-
- # Change size distribution
- size_distribution = {}
- for commit in commits:
- size_category = commit.get_change_size_category()
- size_distribution[size_category] = size_distribution.get(size_category, 0) + 1
-
- # Average lines per commit
- total_lines = sum(commit.total_lines_changed for commit in commits)
- avg_lines_per_commit = total_lines / total_commits if total_commits > 0 else 0
-
- # Daily commit frequency
- daily_commits = {}
- for commit in commits:
- date_key = commit.timestamp.date().isoformat()
- daily_commits[date_key] = daily_commits.get(date_key, 0) + 1
-
- commit_frequency = [
- {"date": date, "commits": count}
- for date, count in sorted(daily_commits.items())
- ]
-
- return {
- "total_commits": total_commits,
- "commit_categories": categories,
- "change_size_distribution": size_distribution,
- "average_lines_per_commit": round(avg_lines_per_commit, 1),
- "commit_frequency": commit_frequency,
- "top_commit_messages": [
- {
- "message": commit.get_commit_message(),
- "lines_changed": commit.total_lines_changed,
- "timestamp": commit.timestamp
- }
- for commit in sorted(commits, key=lambda c: c.total_lines_changed, reverse=True)[:5]
- if commit.get_commit_message()
- ]
- }
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get commit stats: {str(e)}"
- )
-
-
-@router.get("/git/stats/activity")
-async def get_git_activity_stats(
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(30, description="Number of days to include"),
- db: AsyncSession = Depends(get_db)
-):
- """Get overall git activity statistics."""
- try:
- query = select(GitOperation)
-
- # Apply filters
- if project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- if days > 0:
- from datetime import datetime, timedelta
- start_date = datetime.utcnow() - timedelta(days=days)
- query = query.where(GitOperation.timestamp >= start_date)
-
- result = await db.execute(query)
- operations = result.scalars().all()
-
- if not operations:
- return {
- "total_operations": 0,
- "operations_by_type": {},
- "success_rate": 0.0,
- "most_active_days": []
- }
-
- # Operations by type
- operations_by_type = {}
- successful_operations = 0
-
- for op in operations:
- operations_by_type[op.operation] = operations_by_type.get(op.operation, 0) + 1
- if op.success:
- successful_operations += 1
-
- success_rate = successful_operations / len(operations) * 100 if operations else 0
-
- # Daily activity
- daily_activity = {}
- for op in operations:
- date_key = op.timestamp.date().isoformat()
- if date_key not in daily_activity:
- daily_activity[date_key] = 0
- daily_activity[date_key] += 1
-
- most_active_days = [
- {"date": date, "operations": count}
- for date, count in sorted(daily_activity.items(), key=lambda x: x[1], reverse=True)[:7]
- ]
-
- return {
- "total_operations": len(operations),
- "operations_by_type": operations_by_type,
- "success_rate": round(success_rate, 1),
- "most_active_days": most_active_days,
- "timeline": [
- {
- "date": date,
- "operations": count
- }
- for date, count in sorted(daily_activity.items())
- ]
- }
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get git activity stats: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/api/projects.py b/app/api/projects.py
deleted file mode 100644
index 4d48135..0000000
--- a/app/api/projects.py
+++ /dev/null
@@ -1,430 +0,0 @@
-"""
-Project data retrieval API endpoints.
-"""
-
-from typing import List, Optional
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.project import Project
-from app.models.session import Session
-from app.models.conversation import Conversation
-from app.models.activity import Activity
-from app.models.waiting_period import WaitingPeriod
-from app.models.git_operation import GitOperation
-from app.api.schemas import ProjectSummary, ProjectTimeline, TimelineEvent
-
-router = APIRouter()
-
-
-@router.get("/projects", response_model=List[ProjectSummary])
-async def list_projects(
- limit: int = Query(50, description="Maximum number of results"),
- offset: int = Query(0, description="Number of results to skip"),
- db: AsyncSession = Depends(get_db)
-):
- """Get list of all tracked projects with summary statistics."""
- try:
- # Get projects with basic info
- query = select(Project).order_by(Project.last_session.desc().nullslast()).offset(offset).limit(limit)
- result = await db.execute(query)
- projects = result.scalars().all()
-
- project_summaries = []
-
- for project in projects:
- # Get latest session for last_activity
- latest_session_result = await db.execute(
- select(Session.start_time)
- .where(Session.project_id == project.id)
- .order_by(Session.start_time.desc())
- .limit(1)
- )
- latest_session = latest_session_result.scalars().first()
-
- project_summaries.append(ProjectSummary(
- id=project.id,
- name=project.name,
- path=project.path,
- git_repo=project.git_repo,
- languages=project.languages,
- total_sessions=project.total_sessions,
- total_time_minutes=project.total_time_minutes,
- last_activity=latest_session or project.created_at,
- files_modified_count=project.files_modified_count,
- lines_changed_count=project.lines_changed_count
- ))
-
- return project_summaries
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to list projects: {str(e)}"
- )
-
-
-@router.get("/projects/{project_id}", response_model=ProjectSummary)
-async def get_project(
- project_id: int,
- db: AsyncSession = Depends(get_db)
-):
- """Get detailed information about a specific project."""
- try:
- result = await db.execute(
- select(Project).where(Project.id == project_id)
- )
- project = result.scalars().first()
-
- if not project:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Project {project_id} not found"
- )
-
- # Get latest session for last_activity
- latest_session_result = await db.execute(
- select(Session.start_time)
- .where(Session.project_id == project.id)
- .order_by(Session.start_time.desc())
- .limit(1)
- )
- latest_session = latest_session_result.scalars().first()
-
- return ProjectSummary(
- id=project.id,
- name=project.name,
- path=project.path,
- git_repo=project.git_repo,
- languages=project.languages,
- total_sessions=project.total_sessions,
- total_time_minutes=project.total_time_minutes,
- last_activity=latest_session or project.created_at,
- files_modified_count=project.files_modified_count,
- lines_changed_count=project.lines_changed_count
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get project: {str(e)}"
- )
-
-
-@router.get("/projects/{project_id}/timeline", response_model=ProjectTimeline)
-async def get_project_timeline(
- project_id: int,
- start_date: Optional[str] = Query(None, description="Start date (YYYY-MM-DD)"),
- end_date: Optional[str] = Query(None, description="End date (YYYY-MM-DD)"),
- db: AsyncSession = Depends(get_db)
-):
- """Get chronological timeline of project development."""
- try:
- # Get project info
- project_result = await db.execute(
- select(Project).where(Project.id == project_id)
- )
- project = project_result.scalars().first()
-
- if not project:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Project {project_id} not found"
- )
-
- # Parse date filters
- date_filters = []
- if start_date:
- from datetime import datetime
- start_dt = datetime.fromisoformat(start_date)
- date_filters.append(lambda table: table.timestamp >= start_dt if hasattr(table, 'timestamp') else table.start_time >= start_dt)
-
- if end_date:
- from datetime import datetime
- end_dt = datetime.fromisoformat(end_date + " 23:59:59")
- date_filters.append(lambda table: table.timestamp <= end_dt if hasattr(table, 'timestamp') else table.start_time <= end_dt)
-
- timeline_events = []
-
- # Get sessions for this project
- session_query = select(Session).where(Session.project_id == project_id)
- session_result = await db.execute(session_query)
- sessions = session_result.scalars().all()
- session_ids = [s.id for s in sessions]
-
- # Session start/end events
- for session in sessions:
- # Session start
- timeline_events.append(TimelineEvent(
- timestamp=session.start_time,
- type="session_start",
- data={
- "session_id": session.id,
- "session_type": session.session_type,
- "git_branch": session.git_branch,
- "working_directory": session.working_directory
- }
- ))
-
- # Session end (if ended)
- if session.end_time:
- timeline_events.append(TimelineEvent(
- timestamp=session.end_time,
- type="session_end",
- data={
- "session_id": session.id,
- "duration_minutes": session.duration_minutes,
- "activity_count": session.activity_count,
- "conversation_count": session.conversation_count
- }
- ))
-
- if session_ids:
- # Get conversations
- conv_query = select(Conversation).where(Conversation.session_id.in_(session_ids))
- if date_filters:
- for date_filter in date_filters:
- conv_query = conv_query.where(date_filter(Conversation))
-
- conv_result = await db.execute(conv_query)
- conversations = conv_result.scalars().all()
-
- for conv in conversations:
- timeline_events.append(TimelineEvent(
- timestamp=conv.timestamp,
- type="conversation",
- data={
- "id": conv.id,
- "session_id": conv.session_id,
- "exchange_type": conv.exchange_type,
- "user_prompt": conv.user_prompt[:100] + "..." if conv.user_prompt and len(conv.user_prompt) > 100 else conv.user_prompt,
- "tools_used": conv.tools_used,
- "files_affected": conv.files_affected
- }
- ))
-
- # Get activities
- activity_query = select(Activity).where(Activity.session_id.in_(session_ids))
- if date_filters:
- for date_filter in date_filters:
- activity_query = activity_query.where(date_filter(Activity))
-
- activity_result = await db.execute(activity_query)
- activities = activity_result.scalars().all()
-
- for activity in activities:
- timeline_events.append(TimelineEvent(
- timestamp=activity.timestamp,
- type="activity",
- data={
- "id": activity.id,
- "session_id": activity.session_id,
- "tool_name": activity.tool_name,
- "action": activity.action,
- "file_path": activity.file_path,
- "success": activity.success,
- "lines_changed": activity.total_lines_changed
- }
- ))
-
- # Get git operations
- git_query = select(GitOperation).where(GitOperation.session_id.in_(session_ids))
- if date_filters:
- for date_filter in date_filters:
- git_query = git_query.where(date_filter(GitOperation))
-
- git_result = await db.execute(git_query)
- git_operations = git_result.scalars().all()
-
- for git_op in git_operations:
- timeline_events.append(TimelineEvent(
- timestamp=git_op.timestamp,
- type="git_operation",
- data={
- "id": git_op.id,
- "session_id": git_op.session_id,
- "operation": git_op.operation,
- "commit_hash": git_op.commit_hash,
- "commit_message": git_op.get_commit_message(),
- "files_changed": git_op.files_count,
- "lines_changed": git_op.total_lines_changed
- }
- ))
-
- # Sort timeline by timestamp
- timeline_events.sort(key=lambda x: x.timestamp)
-
- # Create project summary for response
- latest_session_result = await db.execute(
- select(Session.start_time)
- .where(Session.project_id == project.id)
- .order_by(Session.start_time.desc())
- .limit(1)
- )
- latest_session = latest_session_result.scalars().first()
-
- project_summary = ProjectSummary(
- id=project.id,
- name=project.name,
- path=project.path,
- git_repo=project.git_repo,
- languages=project.languages,
- total_sessions=project.total_sessions,
- total_time_minutes=project.total_time_minutes,
- last_activity=latest_session or project.created_at,
- files_modified_count=project.files_modified_count,
- lines_changed_count=project.lines_changed_count
- )
-
- return ProjectTimeline(
- project=project_summary,
- timeline=timeline_events
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get project timeline: {str(e)}"
- )
-
-
-@router.get("/projects/{project_id}/stats")
-async def get_project_stats(
- project_id: int,
- days: int = Query(30, description="Number of days to include in statistics"),
- db: AsyncSession = Depends(get_db)
-):
- """Get comprehensive statistics for a project."""
- try:
- # Verify project exists
- project_result = await db.execute(
- select(Project).where(Project.id == project_id)
- )
- project = project_result.scalars().first()
-
- if not project:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Project {project_id} not found"
- )
-
- # Date filter for recent activity
- from datetime import datetime, timedelta
- start_date = datetime.utcnow() - timedelta(days=days) if days > 0 else None
-
- # Get sessions
- session_query = select(Session).where(Session.project_id == project_id)
- if start_date:
- session_query = session_query.where(Session.start_time >= start_date)
-
- session_result = await db.execute(session_query)
- sessions = session_result.scalars().all()
- session_ids = [s.id for s in sessions] if sessions else []
-
- # Calculate session statistics
- total_sessions = len(sessions)
- total_time = sum(s.calculated_duration_minutes or 0 for s in sessions)
- avg_session_length = total_time / total_sessions if total_sessions > 0 else 0
-
- # Activity statistics
- activity_stats = {"total": 0, "by_tool": {}, "by_language": {}}
- if session_ids:
- activity_query = select(Activity).where(Activity.session_id.in_(session_ids))
- activity_result = await db.execute(activity_query)
- activities = activity_result.scalars().all()
-
- activity_stats["total"] = len(activities)
-
- for activity in activities:
- # Tool usage
- tool = activity.tool_name
- activity_stats["by_tool"][tool] = activity_stats["by_tool"].get(tool, 0) + 1
-
- # Language usage
- lang = activity.get_programming_language()
- if lang:
- activity_stats["by_language"][lang] = activity_stats["by_language"].get(lang, 0) + 1
-
- # Conversation statistics
- conversation_stats = {"total": 0, "by_type": {}}
- if session_ids:
- conv_query = select(Conversation).where(Conversation.session_id.in_(session_ids))
- conv_result = await db.execute(conv_query)
- conversations = conv_result.scalars().all()
-
- conversation_stats["total"] = len(conversations)
-
- for conv in conversations:
- conv_type = conv.exchange_type
- conversation_stats["by_type"][conv_type] = conversation_stats["by_type"].get(conv_type, 0) + 1
-
- # Git statistics
- git_stats = {"total": 0, "commits": 0, "by_operation": {}}
- if session_ids:
- git_query = select(GitOperation).where(GitOperation.session_id.in_(session_ids))
- git_result = await db.execute(git_query)
- git_operations = git_result.scalars().all()
-
- git_stats["total"] = len(git_operations)
-
- for git_op in git_operations:
- if git_op.is_commit:
- git_stats["commits"] += 1
-
- op_type = git_op.operation
- git_stats["by_operation"][op_type] = git_stats["by_operation"].get(op_type, 0) + 1
-
- # Productivity trends (daily aggregation)
- daily_stats = {}
- for session in sessions:
- date_key = session.start_time.date().isoformat()
- if date_key not in daily_stats:
- daily_stats[date_key] = {
- "date": date_key,
- "sessions": 0,
- "time_minutes": 0,
- "activities": 0
- }
-
- daily_stats[date_key]["sessions"] += 1
- daily_stats[date_key]["time_minutes"] += session.calculated_duration_minutes or 0
- daily_stats[date_key]["activities"] += session.activity_count
-
- productivity_trends = list(daily_stats.values())
- productivity_trends.sort(key=lambda x: x["date"])
-
- return {
- "project_id": project_id,
- "project_name": project.name,
- "time_period_days": days,
- "session_statistics": {
- "total_sessions": total_sessions,
- "total_time_minutes": total_time,
- "average_session_length_minutes": round(avg_session_length, 1)
- },
- "activity_statistics": activity_stats,
- "conversation_statistics": conversation_stats,
- "git_statistics": git_stats,
- "productivity_trends": productivity_trends,
- "summary": {
- "most_used_tool": max(activity_stats["by_tool"].items(), key=lambda x: x[1])[0] if activity_stats["by_tool"] else None,
- "primary_language": max(activity_stats["by_language"].items(), key=lambda x: x[1])[0] if activity_stats["by_language"] else None,
- "daily_average_time": round(total_time / days, 1) if days > 0 else 0,
- "daily_average_sessions": round(total_sessions / days, 1) if days > 0 else 0
- }
- }
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get project stats: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/api/schemas.py b/app/api/schemas.py
deleted file mode 100644
index e133eeb..0000000
--- a/app/api/schemas.py
+++ /dev/null
@@ -1,220 +0,0 @@
-"""
-Pydantic schemas for API request/response models.
-"""
-
-from datetime import datetime
-from typing import Optional, List, Dict, Any, Union
-from pydantic import BaseModel, Field
-
-
-# Base schemas
-class TimestampMixin(BaseModel):
- """Mixin for timestamp fields."""
- created_at: datetime
- updated_at: datetime
-
-
-# Session schemas
-class SessionStartRequest(BaseModel):
- """Request schema for starting a session."""
- session_type: str = Field(..., description="Type of session: startup, resume, or clear")
- working_directory: str = Field(..., description="Current working directory")
- git_branch: Optional[str] = Field(None, description="Current git branch")
- git_repo: Optional[str] = Field(None, description="Git repository URL")
- environment: Optional[Dict[str, Any]] = Field(None, description="Environment variables and context")
-
-
-class SessionEndRequest(BaseModel):
- """Request schema for ending a session."""
- session_id: int = Field(..., description="ID of the session to end")
- end_reason: str = Field(default="normal", description="Reason for ending: normal, interrupted, or timeout")
-
-
-class SessionResponse(BaseModel):
- """Response schema for session operations."""
- session_id: int
- project_id: int
- status: str
- message: Optional[str] = None
-
- class Config:
- from_attributes = True
-
-
-# Conversation schemas
-class ConversationRequest(BaseModel):
- """Request schema for logging conversations."""
- session_id: int = Field(..., description="Associated session ID")
- timestamp: datetime = Field(default_factory=datetime.utcnow, description="When the exchange occurred")
- user_prompt: Optional[str] = Field(None, description="User's input message")
- claude_response: Optional[str] = Field(None, description="Claude's response")
- tools_used: Optional[List[str]] = Field(None, description="Tools used in the response")
- files_affected: Optional[List[str]] = Field(None, description="Files mentioned or modified")
- context: Optional[Dict[str, Any]] = Field(None, description="Additional context")
- tokens_input: Optional[int] = Field(None, description="Estimated input token count")
- tokens_output: Optional[int] = Field(None, description="Estimated output token count")
- exchange_type: str = Field(..., description="Type of exchange: user_prompt or claude_response")
-
-
-class ConversationResponse(BaseModel):
- """Response schema for conversation operations."""
- id: int
- session_id: int
- timestamp: datetime
- exchange_type: str
- content_length: int
-
- class Config:
- from_attributes = True
-
-
-# Activity schemas
-class ActivityRequest(BaseModel):
- """Request schema for recording activities."""
- session_id: int = Field(..., description="Associated session ID")
- conversation_id: Optional[int] = Field(None, description="Associated conversation ID")
- timestamp: datetime = Field(default_factory=datetime.utcnow, description="When the activity occurred")
- tool_name: str = Field(..., description="Name of the tool used")
- action: str = Field(..., description="Specific action taken")
- file_path: Optional[str] = Field(None, description="Target file path if applicable")
- metadata: Optional[Dict[str, Any]] = Field(None, description="Tool-specific metadata")
- success: bool = Field(default=True, description="Whether the operation succeeded")
- error_message: Optional[str] = Field(None, description="Error details if failed")
- lines_added: Optional[int] = Field(None, description="Lines added for Edit/Write operations")
- lines_removed: Optional[int] = Field(None, description="Lines removed for Edit operations")
-
-
-class ActivityResponse(BaseModel):
- """Response schema for activity operations."""
- id: int
- session_id: int
- tool_name: str
- action: str
- timestamp: datetime
- success: bool
-
- class Config:
- from_attributes = True
-
-
-# Waiting period schemas
-class WaitingStartRequest(BaseModel):
- """Request schema for starting a waiting period."""
- session_id: int = Field(..., description="Associated session ID")
- timestamp: datetime = Field(default_factory=datetime.utcnow, description="When waiting started")
- context_before: Optional[str] = Field(None, description="Context before waiting")
-
-
-class WaitingEndRequest(BaseModel):
- """Request schema for ending a waiting period."""
- session_id: int = Field(..., description="Associated session ID")
- timestamp: datetime = Field(default_factory=datetime.utcnow, description="When waiting ended")
- duration_seconds: Optional[int] = Field(None, description="Total waiting duration")
- context_after: Optional[str] = Field(None, description="Context after waiting")
-
-
-class WaitingPeriodResponse(BaseModel):
- """Response schema for waiting period operations."""
- id: int
- session_id: int
- start_time: datetime
- end_time: Optional[datetime]
- duration_seconds: Optional[int]
- engagement_score: float
-
- class Config:
- from_attributes = True
-
-
-# Git operation schemas
-class GitOperationRequest(BaseModel):
- """Request schema for git operations."""
- session_id: int = Field(..., description="Associated session ID")
- timestamp: datetime = Field(default_factory=datetime.utcnow, description="When the operation occurred")
- operation: str = Field(..., description="Type of git operation")
- command: str = Field(..., description="Full git command executed")
- result: Optional[str] = Field(None, description="Command output")
- success: bool = Field(default=True, description="Whether the command succeeded")
- files_changed: Optional[List[str]] = Field(None, description="Files affected by the operation")
- lines_added: Optional[int] = Field(None, description="Lines added")
- lines_removed: Optional[int] = Field(None, description="Lines removed")
- commit_hash: Optional[str] = Field(None, description="Git commit SHA")
- branch_from: Optional[str] = Field(None, description="Source branch")
- branch_to: Optional[str] = Field(None, description="Target branch")
-
-
-class GitOperationResponse(BaseModel):
- """Response schema for git operations."""
- id: int
- session_id: int
- operation: str
- timestamp: datetime
- success: bool
- commit_hash: Optional[str]
-
- class Config:
- from_attributes = True
-
-
-# Project schemas
-class ProjectSummary(BaseModel):
- """Summary information about a project."""
- id: int
- name: str
- path: str
- git_repo: Optional[str]
- languages: Optional[List[str]]
- total_sessions: int
- total_time_minutes: int
- last_activity: Optional[datetime]
- files_modified_count: int
- lines_changed_count: int
-
- class Config:
- from_attributes = True
-
-
-class TimelineEvent(BaseModel):
- """Individual event in project timeline."""
- timestamp: datetime
- type: str # session_start, session_end, conversation, activity, git_operation
- data: Dict[str, Any]
-
-
-class ProjectTimeline(BaseModel):
- """Project timeline with events."""
- project: ProjectSummary
- timeline: List[TimelineEvent]
-
-
-# Analytics schemas
-class ProductivityMetrics(BaseModel):
- """Productivity analytics response."""
- engagement_score: float = Field(..., description="Overall engagement level (0-100)")
- average_session_length: float = Field(..., description="Minutes per session")
- think_time_average: float = Field(..., description="Average waiting time between interactions")
- files_per_session: float = Field(..., description="Average files touched per session")
- tools_most_used: List[Dict[str, Union[str, int]]] = Field(..., description="Most frequently used tools")
- productivity_trends: List[Dict[str, Union[str, float]]] = Field(..., description="Daily productivity scores")
-
-
-class ConversationSearchResult(BaseModel):
- """Search result for conversation search."""
- id: int
- project_name: str
- timestamp: datetime
- user_prompt: Optional[str]
- claude_response: Optional[str]
- relevance_score: float
- context: List[str]
-
- class Config:
- from_attributes = True
-
-
-# Error schemas
-class ErrorResponse(BaseModel):
- """Standard error response."""
- error: str
- message: str
- details: Optional[Dict[str, Any]] = None
\ No newline at end of file
diff --git a/app/api/sessions.py b/app/api/sessions.py
deleted file mode 100644
index 4d4676a..0000000
--- a/app/api/sessions.py
+++ /dev/null
@@ -1,255 +0,0 @@
-"""
-Session management API endpoints.
-"""
-
-import os
-from typing import Optional
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.project import Project
-from app.models.session import Session
-from app.api.schemas import SessionStartRequest, SessionEndRequest, SessionResponse
-
-router = APIRouter()
-
-
-async def get_or_create_project(
- db: AsyncSession,
- working_directory: str,
- git_repo: Optional[str] = None
-) -> Project:
- """Get existing project or create a new one based on working directory."""
-
- # Try to find existing project by path
- result = await db.execute(
- select(Project).where(Project.path == working_directory)
- )
- project = result.scalars().first()
-
- if project:
- return project
-
- # Create new project
- project_name = os.path.basename(working_directory) or "Unknown Project"
-
- # Try to infer languages from directory (simple heuristic)
- languages = []
- try:
- for root, dirs, files in os.walk(working_directory):
- for file in files:
- ext = os.path.splitext(file)[1].lower()
- if ext == ".py":
- languages.append("python")
- elif ext in [".js", ".jsx"]:
- languages.append("javascript")
- elif ext in [".ts", ".tsx"]:
- languages.append("typescript")
- elif ext == ".go":
- languages.append("go")
- elif ext == ".rs":
- languages.append("rust")
- elif ext == ".java":
- languages.append("java")
- elif ext in [".cpp", ".cc", ".cxx"]:
- languages.append("cpp")
- elif ext == ".c":
- languages.append("c")
- # Don't traverse too deep
- if len(root.replace(working_directory, "").split(os.sep)) > 2:
- break
-
- languages = list(set(languages))[:5] # Keep unique, limit to 5
- except (OSError, PermissionError):
- # If we can't read the directory, that's okay
- pass
-
- project = Project(
- name=project_name,
- path=working_directory,
- git_repo=git_repo,
- languages=languages if languages else None
- )
-
- db.add(project)
- await db.commit()
- await db.refresh(project)
-
- return project
-
-
-@router.post("/session/start", response_model=SessionResponse, status_code=status.HTTP_201_CREATED)
-async def start_session(
- request: SessionStartRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- Start a new development session.
-
- This endpoint is called by Claude Code hooks when a session begins.
- It will create a project if one doesn't exist for the working directory.
- """
- try:
- # Get or create project
- project = await get_or_create_project(
- db=db,
- working_directory=request.working_directory,
- git_repo=request.git_repo
- )
-
- # Create new session
- session = Session(
- project_id=project.id,
- session_type=request.session_type,
- working_directory=request.working_directory,
- git_branch=request.git_branch,
- environment=request.environment
- )
-
- db.add(session)
- await db.commit()
- await db.refresh(session)
-
- # Store session ID in temp file for hooks to use
- session_file = "/tmp/claude-session-id"
- try:
- with open(session_file, "w") as f:
- f.write(str(session.id))
- except OSError:
- # If we can't write the session file, log but don't fail
- pass
-
- return SessionResponse(
- session_id=session.id,
- project_id=project.id,
- status="started",
- message=f"Session started for project '{project.name}'"
- )
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to start session: {str(e)}"
- )
-
-
-@router.post("/session/end", response_model=SessionResponse)
-async def end_session(
- request: SessionEndRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- End an active development session.
-
- This endpoint calculates final session statistics and updates
- project-level metrics.
- """
- try:
- # Find the session
- result = await db.execute(
- select(Session)
- .options(selectinload(Session.project))
- .where(Session.id == request.session_id)
- )
- session = result.scalars().first()
-
- if not session:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Session {request.session_id} not found"
- )
-
- if not session.is_active:
- raise HTTPException(
- status_code=status.HTTP_400_BAD_REQUEST,
- detail="Session is already ended"
- )
-
- # End the session
- session.end_session(end_reason=request.end_reason)
- await db.commit()
-
- # Clean up session ID file
- session_file = "/tmp/claude-session-id"
- try:
- if os.path.exists(session_file):
- os.remove(session_file)
- except OSError:
- pass
-
- return SessionResponse(
- session_id=session.id,
- project_id=session.project_id,
- status="ended",
- message=f"Session ended after {session.duration_minutes} minutes"
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to end session: {str(e)}"
- )
-
-
-@router.get("/sessions/{session_id}", response_model=dict)
-async def get_session(
- session_id: int,
- db: AsyncSession = Depends(get_db)
-):
- """Get detailed information about a specific session."""
- try:
- result = await db.execute(
- select(Session)
- .options(
- selectinload(Session.project),
- selectinload(Session.conversations),
- selectinload(Session.activities),
- selectinload(Session.waiting_periods),
- selectinload(Session.git_operations)
- )
- .where(Session.id == session_id)
- )
- session = result.scalars().first()
-
- if not session:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Session {session_id} not found"
- )
-
- return {
- "id": session.id,
- "project": {
- "id": session.project.id,
- "name": session.project.name,
- "path": session.project.path
- },
- "start_time": session.start_time,
- "end_time": session.end_time,
- "duration_minutes": session.calculated_duration_minutes,
- "session_type": session.session_type,
- "git_branch": session.git_branch,
- "activity_count": session.activity_count,
- "conversation_count": session.conversation_count,
- "is_active": session.is_active,
- "statistics": {
- "conversations": len(session.conversations),
- "activities": len(session.activities),
- "waiting_periods": len(session.waiting_periods),
- "git_operations": len(session.git_operations),
- "files_touched": len(session.files_touched or [])
- }
- }
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get session: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/api/waiting.py b/app/api/waiting.py
deleted file mode 100644
index 7a7a292..0000000
--- a/app/api/waiting.py
+++ /dev/null
@@ -1,285 +0,0 @@
-"""
-Waiting period tracking API endpoints.
-"""
-
-from typing import List, Optional
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func
-from sqlalchemy.orm import selectinload
-
-from app.database.connection import get_db
-from app.models.waiting_period import WaitingPeriod
-from app.models.session import Session
-from app.api.schemas import WaitingStartRequest, WaitingEndRequest, WaitingPeriodResponse
-
-router = APIRouter()
-
-
-@router.post("/waiting/start", response_model=WaitingPeriodResponse, status_code=status.HTTP_201_CREATED)
-async def start_waiting_period(
- request: WaitingStartRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- Start a new waiting period.
-
- Called by the Notification hook when Claude is waiting for user input.
- """
- try:
- # Verify session exists
- result = await db.execute(
- select(Session).where(Session.id == request.session_id)
- )
- session = result.scalars().first()
-
- if not session:
- raise HTTPException(
- status_code=status.HTTP_404_NOT_FOUND,
- detail=f"Session {request.session_id} not found"
- )
-
- # Check if there's already an active waiting period for this session
- active_waiting = await db.execute(
- select(WaitingPeriod).where(
- WaitingPeriod.session_id == request.session_id,
- WaitingPeriod.end_time.is_(None)
- )
- )
- existing = active_waiting.scalars().first()
-
- if existing:
- # End the existing waiting period first
- existing.end_waiting()
-
- # Create new waiting period
- waiting_period = WaitingPeriod(
- session_id=request.session_id,
- start_time=request.timestamp,
- context_before=request.context_before
- )
-
- db.add(waiting_period)
- await db.commit()
- await db.refresh(waiting_period)
-
- return WaitingPeriodResponse(
- id=waiting_period.id,
- session_id=waiting_period.session_id,
- start_time=waiting_period.start_time,
- end_time=waiting_period.end_time,
- duration_seconds=waiting_period.calculated_duration_seconds,
- engagement_score=waiting_period.engagement_score
- )
-
- except HTTPException:
- raise
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to start waiting period: {str(e)}"
- )
-
-
-@router.post("/waiting/end", response_model=WaitingPeriodResponse)
-async def end_waiting_period(
- request: WaitingEndRequest,
- db: AsyncSession = Depends(get_db)
-):
- """
- End the current waiting period for a session.
-
- Called when the user submits new input or the Stop hook triggers.
- """
- try:
- # Find the active waiting period for this session
- result = await db.execute(
- select(WaitingPeriod).where(
- WaitingPeriod.session_id == request.session_id,
- WaitingPeriod.end_time.is_(None)
- )
- )
- waiting_period = result.scalars().first()
-
- if not waiting_period:
- # If no active waiting period, that's okay - just return success
- return WaitingPeriodResponse(
- id=0,
- session_id=request.session_id,
- start_time=request.timestamp,
- end_time=request.timestamp,
- duration_seconds=0,
- engagement_score=1.0
- )
-
- # End the waiting period
- waiting_period.end_time = request.timestamp
- waiting_period.duration_seconds = request.duration_seconds or waiting_period.calculated_duration_seconds
- waiting_period.context_after = request.context_after
-
- # Classify the activity based on duration
- waiting_period.likely_activity = waiting_period.classify_activity()
-
- await db.commit()
- await db.refresh(waiting_period)
-
- return WaitingPeriodResponse(
- id=waiting_period.id,
- session_id=waiting_period.session_id,
- start_time=waiting_period.start_time,
- end_time=waiting_period.end_time,
- duration_seconds=waiting_period.duration_seconds,
- engagement_score=waiting_period.engagement_score
- )
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to end waiting period: {str(e)}"
- )
-
-
-@router.get("/waiting/periods")
-async def get_waiting_periods(
- session_id: Optional[int] = Query(None, description="Filter by session ID"),
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- limit: int = Query(50, description="Maximum number of results"),
- offset: int = Query(0, description="Number of results to skip"),
- db: AsyncSession = Depends(get_db)
-):
- """Get waiting periods with optional filtering."""
- try:
- query = select(WaitingPeriod).options(
- selectinload(WaitingPeriod.session).selectinload(Session.project)
- )
-
- # Apply filters
- if session_id:
- query = query.where(WaitingPeriod.session_id == session_id)
- elif project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- # Order by start time descending
- query = query.order_by(WaitingPeriod.start_time.desc()).offset(offset).limit(limit)
-
- result = await db.execute(query)
- waiting_periods = result.scalars().all()
-
- return [
- {
- "id": period.id,
- "session_id": period.session_id,
- "project_name": period.session.project.name,
- "start_time": period.start_time,
- "end_time": period.end_time,
- "duration_seconds": period.calculated_duration_seconds,
- "duration_minutes": period.duration_minutes,
- "likely_activity": period.classify_activity(),
- "engagement_score": period.engagement_score,
- "context_before": period.context_before,
- "context_after": period.context_after,
- "is_quick_response": period.is_quick_response(),
- "is_thoughtful_pause": period.is_thoughtful_pause(),
- "is_research_break": period.is_research_break(),
- "is_extended_break": period.is_extended_break()
- }
- for period in waiting_periods
- ]
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get waiting periods: {str(e)}"
- )
-
-
-@router.get("/waiting/stats/engagement")
-async def get_engagement_stats(
- session_id: Optional[int] = Query(None, description="Filter by session ID"),
- project_id: Optional[int] = Query(None, description="Filter by project ID"),
- days: int = Query(7, description="Number of days to include"),
- db: AsyncSession = Depends(get_db)
-):
- """Get engagement statistics based on waiting periods."""
- try:
- # Base query for waiting periods
- query = select(WaitingPeriod).where(WaitingPeriod.duration_seconds.isnot(None))
-
- # Apply filters
- if session_id:
- query = query.where(WaitingPeriod.session_id == session_id)
- elif project_id:
- query = query.join(Session).where(Session.project_id == project_id)
-
- # Filter by date range
- if days > 0:
- from datetime import datetime, timedelta
- start_date = datetime.utcnow() - timedelta(days=days)
- query = query.where(WaitingPeriod.start_time >= start_date)
-
- result = await db.execute(query)
- waiting_periods = result.scalars().all()
-
- if not waiting_periods:
- return {
- "total_periods": 0,
- "average_engagement_score": 0.0,
- "average_think_time_seconds": 0.0,
- "activity_distribution": {},
- "engagement_trends": []
- }
-
- # Calculate statistics
- total_periods = len(waiting_periods)
- engagement_scores = [period.engagement_score for period in waiting_periods]
- durations = [period.duration_seconds for period in waiting_periods]
-
- average_engagement = sum(engagement_scores) / len(engagement_scores)
- average_think_time = sum(durations) / len(durations)
-
- # Activity distribution
- activity_counts = {}
- for period in waiting_periods:
- activity = period.classify_activity()
- activity_counts[activity] = activity_counts.get(activity, 0) + 1
-
- activity_distribution = {
- activity: count / total_periods
- for activity, count in activity_counts.items()
- }
-
- # Engagement trends (daily averages)
- daily_engagement = {}
- for period in waiting_periods:
- date_key = period.start_time.date().isoformat()
- if date_key not in daily_engagement:
- daily_engagement[date_key] = []
- daily_engagement[date_key].append(period.engagement_score)
-
- engagement_trends = [
- {
- "date": date,
- "engagement_score": sum(scores) / len(scores)
- }
- for date, scores in sorted(daily_engagement.items())
- ]
-
- return {
- "total_periods": total_periods,
- "average_engagement_score": round(average_engagement, 3),
- "average_think_time_seconds": round(average_think_time, 1),
- "activity_distribution": activity_distribution,
- "engagement_trends": engagement_trends,
- "response_time_breakdown": {
- "quick_responses": sum(1 for p in waiting_periods if p.is_quick_response()),
- "thoughtful_pauses": sum(1 for p in waiting_periods if p.is_thoughtful_pause()),
- "research_breaks": sum(1 for p in waiting_periods if p.is_research_break()),
- "extended_breaks": sum(1 for p in waiting_periods if p.is_extended_break())
- }
- }
-
- except Exception as e:
- raise HTTPException(
- status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
- detail=f"Failed to get engagement stats: {str(e)}"
- )
\ No newline at end of file
diff --git a/app/dashboard/__init__.py b/app/dashboard/__init__.py
deleted file mode 100644
index 2fd86b8..0000000
--- a/app/dashboard/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""
-Web dashboard for the Claude Code Project Tracker.
-"""
\ No newline at end of file
diff --git a/app/dashboard/routes.py b/app/dashboard/routes.py
deleted file mode 100644
index 1364495..0000000
--- a/app/dashboard/routes.py
+++ /dev/null
@@ -1,49 +0,0 @@
-"""
-Dashboard web interface routes.
-"""
-
-from fastapi import APIRouter, Request, Depends
-from fastapi.templating import Jinja2Templates
-from fastapi.responses import HTMLResponse
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.database.connection import get_db
-
-dashboard_router = APIRouter()
-templates = Jinja2Templates(directory="app/dashboard/templates")
-
-
-@dashboard_router.get("/dashboard", response_class=HTMLResponse)
-async def dashboard_home(request: Request, db: AsyncSession = Depends(get_db)):
- """Main dashboard page."""
- return templates.TemplateResponse("dashboard.html", {
- "request": request,
- "title": "Claude Code Project Tracker"
- })
-
-
-@dashboard_router.get("/dashboard/projects", response_class=HTMLResponse)
-async def dashboard_projects(request: Request, db: AsyncSession = Depends(get_db)):
- """Projects overview page."""
- return templates.TemplateResponse("projects.html", {
- "request": request,
- "title": "Projects - Claude Code Tracker"
- })
-
-
-@dashboard_router.get("/dashboard/analytics", response_class=HTMLResponse)
-async def dashboard_analytics(request: Request, db: AsyncSession = Depends(get_db)):
- """Analytics and insights page."""
- return templates.TemplateResponse("analytics.html", {
- "request": request,
- "title": "Analytics - Claude Code Tracker"
- })
-
-
-@dashboard_router.get("/dashboard/conversations", response_class=HTMLResponse)
-async def dashboard_conversations(request: Request, db: AsyncSession = Depends(get_db)):
- """Conversation search and history page."""
- return templates.TemplateResponse("conversations.html", {
- "request": request,
- "title": "Conversations - Claude Code Tracker"
- })
\ No newline at end of file
diff --git a/app/dashboard/static/css/dashboard.css b/app/dashboard/static/css/dashboard.css
deleted file mode 100644
index 3593712..0000000
--- a/app/dashboard/static/css/dashboard.css
+++ /dev/null
@@ -1,346 +0,0 @@
-/* Claude Code Project Tracker Dashboard Styles */
-
-:root {
- --primary-color: #007bff;
- --secondary-color: #6c757d;
- --success-color: #28a745;
- --info-color: #17a2b8;
- --warning-color: #ffc107;
- --danger-color: #dc3545;
- --light-color: #f8f9fa;
- --dark-color: #343a40;
-}
-
-/* Global Styles */
-body {
- background-color: #f5f5f5;
- font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-}
-
-/* Navigation */
-.navbar-brand {
- font-weight: 600;
-}
-
-.navbar-nav .nav-link {
- font-weight: 500;
- transition: color 0.3s ease;
-}
-
-.navbar-nav .nav-link:hover {
- color: #fff !important;
-}
-
-/* Cards */
-.card {
- border: none;
- border-radius: 0.75rem;
- box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
- transition: box-shadow 0.3s ease;
-}
-
-.card:hover {
- box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
-}
-
-.card-header {
- background-color: transparent;
- border-bottom: 1px solid rgba(0, 0, 0, 0.125);
- font-weight: 600;
-}
-
-/* Status Cards */
-.card.bg-primary,
-.card.bg-success,
-.card.bg-info,
-.card.bg-warning,
-.card.bg-danger {
- border: none;
-}
-
-.card.bg-primary .card-body,
-.card.bg-success .card-body,
-.card.bg-info .card-body,
-.card.bg-warning .card-body,
-.card.bg-danger .card-body {
- padding: 1.5rem;
-}
-
-/* Charts */
-.chart-container {
- position: relative;
- height: 300px;
- width: 100%;
-}
-
-/* Tables */
-.table {
- margin-bottom: 0;
-}
-
-.table th {
- border-top: none;
- font-weight: 600;
- color: var(--dark-color);
- font-size: 0.875rem;
- text-transform: uppercase;
- letter-spacing: 0.05em;
-}
-
-.table td {
- vertical-align: middle;
- font-size: 0.9rem;
-}
-
-/* Badges */
-.badge {
- font-size: 0.75rem;
- font-weight: 500;
-}
-
-/* Project List */
-.project-item {
- border-left: 4px solid var(--primary-color);
- background-color: #fff;
- border-radius: 0.5rem;
- padding: 1rem;
- margin-bottom: 0.75rem;
- transition: all 0.3s ease;
-}
-
-.project-item:hover {
- transform: translateX(5px);
- box-shadow: 0 0.25rem 0.5rem rgba(0, 0, 0, 0.1);
-}
-
-.project-title {
- font-weight: 600;
- color: var(--dark-color);
- margin-bottom: 0.25rem;
-}
-
-.project-path {
- color: var(--secondary-color);
- font-size: 0.875rem;
- font-family: 'Courier New', monospace;
-}
-
-.project-stats {
- font-size: 0.8rem;
- color: var(--secondary-color);
-}
-
-/* Activity Timeline */
-.activity-timeline {
- position: relative;
-}
-
-.activity-timeline::before {
- content: '';
- position: absolute;
- left: 20px;
- top: 0;
- bottom: 0;
- width: 2px;
- background-color: var(--light-color);
-}
-
-.timeline-item {
- position: relative;
- padding-left: 50px;
- margin-bottom: 1.5rem;
-}
-
-.timeline-marker {
- position: absolute;
- left: 12px;
- top: 4px;
- width: 16px;
- height: 16px;
- border-radius: 50%;
- background-color: var(--primary-color);
- border: 3px solid #fff;
- box-shadow: 0 0 0 2px var(--primary-color);
-}
-
-.timeline-content {
- background-color: #fff;
- border-radius: 0.5rem;
- padding: 1rem;
- box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
-}
-
-/* Engagement Indicators */
-.engagement-indicator {
- display: inline-block;
- width: 12px;
- height: 12px;
- border-radius: 50%;
- margin-right: 0.5rem;
-}
-
-.engagement-high {
- background-color: var(--success-color);
-}
-
-.engagement-medium {
- background-color: var(--warning-color);
-}
-
-.engagement-low {
- background-color: var(--danger-color);
-}
-
-/* Loading States */
-.loading-skeleton {
- background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
- background-size: 200% 100%;
- animation: loading 1.5s infinite;
-}
-
-@keyframes loading {
- 0% {
- background-position: 200% 0;
- }
- 100% {
- background-position: -200% 0;
- }
-}
-
-/* Responsive Design */
-@media (max-width: 768px) {
- .card-body {
- padding: 1rem;
- }
-
- .project-item {
- margin-bottom: 0.5rem;
- }
-
- .display-4 {
- font-size: 2rem;
- }
-}
-
-/* Search and Filter */
-.search-box {
- border-radius: 50px;
- border: 2px solid var(--light-color);
- transition: border-color 0.3s ease;
-}
-
-.search-box:focus {
- border-color: var(--primary-color);
- box-shadow: none;
-}
-
-/* Custom Scrollbar */
-.custom-scrollbar {
- scrollbar-width: thin;
- scrollbar-color: var(--secondary-color) var(--light-color);
-}
-
-.custom-scrollbar::-webkit-scrollbar {
- width: 8px;
-}
-
-.custom-scrollbar::-webkit-scrollbar-track {
- background: var(--light-color);
- border-radius: 4px;
-}
-
-.custom-scrollbar::-webkit-scrollbar-thumb {
- background: var(--secondary-color);
- border-radius: 4px;
-}
-
-.custom-scrollbar::-webkit-scrollbar-thumb:hover {
- background: var(--dark-color);
-}
-
-/* Tool Icons */
-.tool-icon {
- width: 24px;
- height: 24px;
- display: inline-flex;
- align-items: center;
- justify-content: center;
- border-radius: 4px;
- margin-right: 0.5rem;
- font-size: 0.875rem;
-}
-
-.tool-icon.tool-edit {
- background-color: rgba(40, 167, 69, 0.1);
- color: var(--success-color);
-}
-
-.tool-icon.tool-write {
- background-color: rgba(0, 123, 255, 0.1);
- color: var(--primary-color);
-}
-
-.tool-icon.tool-read {
- background-color: rgba(23, 162, 184, 0.1);
- color: var(--info-color);
-}
-
-.tool-icon.tool-bash {
- background-color: rgba(108, 117, 125, 0.1);
- color: var(--secondary-color);
-}
-
-/* Animation Classes */
-.fade-in {
- animation: fadeIn 0.5s ease-in;
-}
-
-@keyframes fadeIn {
- from {
- opacity: 0;
- transform: translateY(20px);
- }
- to {
- opacity: 1;
- transform: translateY(0);
- }
-}
-
-.slide-in-right {
- animation: slideInRight 0.5s ease-out;
-}
-
-@keyframes slideInRight {
- from {
- opacity: 0;
- transform: translateX(50px);
- }
- to {
- opacity: 1;
- transform: translateX(0);
- }
-}
-
-/* Footer */
-footer {
- margin-top: auto;
- border-top: 1px solid rgba(0, 0, 0, 0.125);
-}
-
-/* Print Styles */
-@media print {
- .navbar,
- .btn,
- footer {
- display: none !important;
- }
-
- .card {
- box-shadow: none !important;
- border: 1px solid #ddd !important;
- }
-
- body {
- background-color: white !important;
- }
-}
\ No newline at end of file
diff --git a/app/dashboard/static/js/api-client.js b/app/dashboard/static/js/api-client.js
deleted file mode 100644
index 24ec8d2..0000000
--- a/app/dashboard/static/js/api-client.js
+++ /dev/null
@@ -1,251 +0,0 @@
-/**
- * API Client for Claude Code Project Tracker
- */
-
-class ApiClient {
- constructor(baseUrl = '') {
- this.baseUrl = baseUrl;
- }
-
- async request(endpoint, options = {}) {
- const url = `${this.baseUrl}/api${endpoint}`;
- const config = {
- headers: {
- 'Content-Type': 'application/json',
- ...options.headers
- },
- ...options
- };
-
- try {
- const response = await fetch(url, config);
-
- if (!response.ok) {
- throw new Error(`HTTP error! status: ${response.status}`);
- }
-
- return await response.json();
- } catch (error) {
- console.error(`API request failed: ${endpoint}`, error);
- throw error;
- }
- }
-
- // Projects API
- async getProjects(limit = 50, offset = 0) {
- return this.request(`/projects?limit=${limit}&offset=${offset}`);
- }
-
- async getProject(projectId) {
- return this.request(`/projects/${projectId}`);
- }
-
- async getProjectTimeline(projectId, startDate = null, endDate = null) {
- let url = `/projects/${projectId}/timeline`;
- const params = new URLSearchParams();
-
- if (startDate) params.append('start_date', startDate);
- if (endDate) params.append('end_date', endDate);
-
- if (params.toString()) {
- url += `?${params.toString()}`;
- }
-
- return this.request(url);
- }
-
- async getProjectStats(projectId, days = 30) {
- return this.request(`/projects/${projectId}/stats?days=${days}`);
- }
-
- // Analytics API
- async getProductivityMetrics(projectId = null, days = 30) {
- let url = `/analytics/productivity?days=${days}`;
- if (projectId) {
- url += `&project_id=${projectId}`;
- }
- return this.request(url);
- }
-
- async getDevelopmentPatterns(projectId = null, days = 30) {
- let url = `/analytics/patterns?days=${days}`;
- if (projectId) {
- url += `&project_id=${projectId}`;
- }
- return this.request(url);
- }
-
- async getLearningInsights(projectId = null, days = 30) {
- let url = `/analytics/learning?days=${days}`;
- if (projectId) {
- url += `&project_id=${projectId}`;
- }
- return this.request(url);
- }
-
- async getAnalyticsSummary(projectId = null) {
- let url = '/analytics/summary';
- if (projectId) {
- url += `?project_id=${projectId}`;
- }
- return this.request(url);
- }
-
- // Conversations API
- async searchConversations(query, projectId = null, limit = 20) {
- let url = `/conversations/search?query=${encodeURIComponent(query)}&limit=${limit}`;
- if (projectId) {
- url += `&project_id=${projectId}`;
- }
- return this.request(url);
- }
-
- async getConversation(conversationId) {
- return this.request(`/conversations/${conversationId}`);
- }
-
- // Activities API
- async getActivities(sessionId = null, toolName = null, limit = 50, offset = 0) {
- let url = `/activities?limit=${limit}&offset=${offset}`;
- if (sessionId) url += `&session_id=${sessionId}`;
- if (toolName) url += `&tool_name=${toolName}`;
- return this.request(url);
- }
-
- async getToolUsageStats(sessionId = null, projectId = null, days = 30) {
- let url = `/activities/stats/tools?days=${days}`;
- if (sessionId) url += `&session_id=${sessionId}`;
- if (projectId) url += `&project_id=${projectId}`;
- return this.request(url);
- }
-
- async getLanguageUsageStats(projectId = null, days = 30) {
- let url = `/activities/stats/languages?days=${days}`;
- if (projectId) url += `&project_id=${projectId}`;
- return this.request(url);
- }
-
- // Waiting Periods API
- async getWaitingPeriods(sessionId = null, projectId = null, limit = 50, offset = 0) {
- let url = `/waiting/periods?limit=${limit}&offset=${offset}`;
- if (sessionId) url += `&session_id=${sessionId}`;
- if (projectId) url += `&project_id=${projectId}`;
- return this.request(url);
- }
-
- async getEngagementStats(sessionId = null, projectId = null, days = 7) {
- let url = `/waiting/stats/engagement?days=${days}`;
- if (sessionId) url += `&session_id=${sessionId}`;
- if (projectId) url += `&project_id=${projectId}`;
- return this.request(url);
- }
-
- // Git Operations API
- async getGitOperations(sessionId = null, projectId = null, operation = null, limit = 50, offset = 0) {
- let url = `/git/operations?limit=${limit}&offset=${offset}`;
- if (sessionId) url += `&session_id=${sessionId}`;
- if (projectId) url += `&project_id=${projectId}`;
- if (operation) url += `&operation=${operation}`;
- return this.request(url);
- }
-
- async getCommitStats(projectId = null, days = 30) {
- let url = `/git/stats/commits?days=${days}`;
- if (projectId) url += `&project_id=${projectId}`;
- return this.request(url);
- }
-
- async getGitActivityStats(projectId = null, days = 30) {
- let url = `/git/stats/activity?days=${days}`;
- if (projectId) url += `&project_id=${projectId}`;
- return this.request(url);
- }
-
- // Sessions API
- async getSession(sessionId) {
- return this.request(`/sessions/${sessionId}`);
- }
-
- // Health check
- async healthCheck() {
- return this.request('/../health');
- }
-}
-
-// Create global API client instance
-const apiClient = new ApiClient();
-
-// Utility functions for common operations
-const ApiUtils = {
- formatDuration: (minutes) => {
- if (minutes < 60) {
- return `${minutes}m`;
- }
- const hours = Math.floor(minutes / 60);
- const remainingMinutes = minutes % 60;
- return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
- },
-
- formatDate: (dateString) => {
- const date = new Date(dateString);
- return date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], {
- hour: '2-digit',
- minute: '2-digit'
- });
- },
-
- formatRelativeTime: (dateString) => {
- const date = new Date(dateString);
- const now = new Date();
- const diffMs = now - date;
- const diffMinutes = Math.floor(diffMs / (1000 * 60));
- const diffHours = Math.floor(diffMinutes / 60);
- const diffDays = Math.floor(diffHours / 24);
-
- if (diffMinutes < 1) return 'just now';
- if (diffMinutes < 60) return `${diffMinutes}m ago`;
- if (diffHours < 24) return `${diffHours}h ago`;
- if (diffDays < 7) return `${diffDays}d ago`;
-
- return date.toLocaleDateString();
- },
-
- getToolIcon: (toolName) => {
- const icons = {
- 'Edit': 'fas fa-edit',
- 'Write': 'fas fa-file-alt',
- 'Read': 'fas fa-eye',
- 'Bash': 'fas fa-terminal',
- 'Grep': 'fas fa-search',
- 'Glob': 'fas fa-folder-open',
- 'Task': 'fas fa-cogs',
- 'WebFetch': 'fas fa-globe'
- };
- return icons[toolName] || 'fas fa-tool';
- },
-
- getToolColor: (toolName) => {
- const colors = {
- 'Edit': 'success',
- 'Write': 'primary',
- 'Read': 'info',
- 'Bash': 'secondary',
- 'Grep': 'warning',
- 'Glob': 'info',
- 'Task': 'dark',
- 'WebFetch': 'primary'
- };
- return colors[toolName] || 'secondary';
- },
-
- getEngagementBadge: (score) => {
- if (score >= 0.8) return { class: 'success', text: 'High' };
- if (score >= 0.5) return { class: 'warning', text: 'Medium' };
- return { class: 'danger', text: 'Low' };
- },
-
- truncateText: (text, maxLength = 100) => {
- if (!text || text.length <= maxLength) return text;
- return text.substring(0, maxLength) + '...';
- }
-};
\ No newline at end of file
diff --git a/app/dashboard/static/js/dashboard.js b/app/dashboard/static/js/dashboard.js
deleted file mode 100644
index 14def00..0000000
--- a/app/dashboard/static/js/dashboard.js
+++ /dev/null
@@ -1,327 +0,0 @@
-/**
- * Dashboard JavaScript functionality
- */
-
-let productivityChart = null;
-let toolsChart = null;
-
-async function loadDashboardData() {
- try {
- // Show loading state
- showLoadingState();
-
- // Load data in parallel
- const [
- analyticsSummary,
- productivityMetrics,
- toolUsageStats,
- recentProjects
- ] = await Promise.all([
- apiClient.getAnalyticsSummary(),
- apiClient.getProductivityMetrics(null, 30),
- apiClient.getToolUsageStats(null, null, 30),
- apiClient.getProjects(5, 0)
- ]);
-
- // Update summary cards
- updateSummaryCards(analyticsSummary);
-
- // Update engagement metrics
- updateEngagementMetrics(productivityMetrics);
-
- // Update charts
- updateProductivityChart(productivityMetrics.productivity_trends);
- updateToolsChart(toolUsageStats);
-
- // Update recent projects
- updateRecentProjects(recentProjects);
-
- // Update quick stats
- updateQuickStats(analyticsSummary);
-
- } catch (error) {
- console.error('Failed to load dashboard data:', error);
- showErrorState('Failed to load dashboard data. Please try refreshing the page.');
- }
-}
-
-function showLoadingState() {
- // Update cards with loading state
- document.getElementById('total-sessions').textContent = '-';
- document.getElementById('total-time').textContent = '-';
- document.getElementById('active-projects').textContent = '-';
- document.getElementById('productivity-score').textContent = '-';
-}
-
-function showErrorState(message) {
- // Show error message
- const alertHtml = `
-
-
- ${message}
-
-
- `;
-
- const container = document.querySelector('.container');
- container.insertAdjacentHTML('afterbegin', alertHtml);
-}
-
-function updateSummaryCards(summary) {
- const overview = summary.overview || {};
-
- document.getElementById('total-sessions').textContent =
- overview.total_sessions?.toLocaleString() || '0';
-
- document.getElementById('total-time').textContent =
- overview.total_time_hours?.toFixed(1) || '0';
-
- document.getElementById('active-projects').textContent =
- overview.projects_tracked?.toLocaleString() || '0';
-
- document.getElementById('productivity-score').textContent =
- overview.productivity_indicators?.productivity_score?.toFixed(0) || '0';
-}
-
-function updateEngagementMetrics(metrics) {
- document.getElementById('engagement-score').textContent =
- metrics.engagement_score?.toFixed(0) || '-';
-
- document.getElementById('avg-session-length').textContent =
- metrics.average_session_length?.toFixed(0) || '-';
-
- document.getElementById('think-time').textContent =
- metrics.think_time_average?.toFixed(0) || '-';
-}
-
-function updateProductivityChart(trendsData) {
- const ctx = document.getElementById('productivityChart').getContext('2d');
-
- // Destroy existing chart
- if (productivityChart) {
- productivityChart.destroy();
- }
-
- const labels = trendsData.map(item => {
- const date = new Date(item.date);
- return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
- });
-
- const data = trendsData.map(item => item.score);
-
- productivityChart = new Chart(ctx, {
- type: 'line',
- data: {
- labels: labels,
- datasets: [{
- label: 'Productivity Score',
- data: data,
- borderColor: '#007bff',
- backgroundColor: 'rgba(0, 123, 255, 0.1)',
- borderWidth: 2,
- fill: true,
- tension: 0.4
- }]
- },
- options: {
- responsive: true,
- maintainAspectRatio: false,
- plugins: {
- legend: {
- display: false
- }
- },
- scales: {
- y: {
- beginAtZero: true,
- max: 100,
- ticks: {
- callback: function(value) {
- return value + '%';
- }
- }
- },
- x: {
- ticks: {
- maxTicksLimit: 7
- }
- }
- }
- }
- });
-}
-
-function updateToolsChart(toolsData) {
- const ctx = document.getElementById('toolsChart').getContext('2d');
-
- // Destroy existing chart
- if (toolsChart) {
- toolsChart.destroy();
- }
-
- // Get top 5 tools
- const topTools = toolsData.slice(0, 5);
- const labels = topTools.map(item => item.tool_name);
- const data = topTools.map(item => item.usage_count);
-
- const colors = [
- '#007bff', '#28a745', '#17a2b8', '#ffc107', '#dc3545'
- ];
-
- toolsChart = new Chart(ctx, {
- type: 'doughnut',
- data: {
- labels: labels,
- datasets: [{
- data: data,
- backgroundColor: colors,
- borderWidth: 2,
- borderColor: '#fff'
- }]
- },
- options: {
- responsive: true,
- maintainAspectRatio: false,
- plugins: {
- legend: {
- position: 'bottom',
- labels: {
- padding: 20,
- usePointStyle: true
- }
- }
- }
- }
- });
-}
-
-function updateRecentProjects(projects) {
- const container = document.getElementById('recent-projects');
-
- if (!projects.length) {
- container.innerHTML = `
-
- `;
- return;
- }
-
- const projectsHtml = projects.map(project => `
-
-
-
-
${project.name}
-
${project.path}
-
-
-
- ${ApiUtils.formatDuration(project.total_time_minutes)}
-
-
-
- ${project.total_sessions} sessions
-
- ${project.languages ? `
-
-
- ${project.languages.slice(0, 2).join(', ')}
-
- ` : ''}
-
-
-
- ${ApiUtils.formatRelativeTime(project.last_activity)}
-
-
-
- `).join('');
-
- container.innerHTML = projectsHtml;
-}
-
-function updateQuickStats(summary) {
- const container = document.getElementById('quick-stats');
- const recent = summary.recent_activity || {};
-
- const statsHtml = `
-
-
-
-
-
-
-
-
${recent.sessions_last_7_days || 0}
-
Sessions this week
-
-
-
-
-
-
-
-
-
-
${(recent.time_last_7_days_hours || 0).toFixed(1)}h
-
Time this week
-
-
-
-
-
-
-
-
-
-
${(recent.daily_average_last_week || 0).toFixed(1)}
-
Daily average
-
-
-
-
-
-
-
-
-
-
${summary.overview?.tracking_period_days || 0}
-
Days tracked
-
-
-
-
- `;
-
- container.innerHTML = statsHtml;
-}
-
-function refreshDashboard() {
- // Add visual feedback
- const refreshBtn = document.querySelector('[onclick="refreshDashboard()"]');
- const icon = refreshBtn.querySelector('i');
-
- icon.classList.add('fa-spin');
- refreshBtn.disabled = true;
-
- loadDashboardData().finally(() => {
- icon.classList.remove('fa-spin');
- refreshBtn.disabled = false;
- });
-}
-
-// Auto-refresh dashboard every 5 minutes
-setInterval(() => {
- loadDashboardData();
-}, 5 * 60 * 1000);
-
-// Handle window resize for charts
-window.addEventListener('resize', () => {
- if (productivityChart) {
- productivityChart.resize();
- }
- if (toolsChart) {
- toolsChart.resize();
- }
-});
\ No newline at end of file
diff --git a/app/dashboard/templates/analytics.html b/app/dashboard/templates/analytics.html
deleted file mode 100644
index d11e293..0000000
--- a/app/dashboard/templates/analytics.html
+++ /dev/null
@@ -1,390 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Analytics - Claude Code Project Tracker{% endblock %}
-
-{% block content %}
-
-
-
-
-
- Development Analytics
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Engagement Score
-
-
-
-
-
-
-
-
-
-
-
- Average Session
- -
-
-
-
-
-
- Files per Session
- -
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-{% endblock %}
-
-{% block scripts %}
-
-{% endblock %}
\ No newline at end of file
diff --git a/app/dashboard/templates/base.html b/app/dashboard/templates/base.html
deleted file mode 100644
index 54c9471..0000000
--- a/app/dashboard/templates/base.html
+++ /dev/null
@@ -1,94 +0,0 @@
-
-
-
-
-
- {% block title %}Claude Code Project Tracker{% endblock %}
-
-
-
-
-
-
-
-
-
-
- {% block content %}{% endblock %}
-
-
-
-
-
-
-
-
-
- {% block scripts %}{% endblock %}
-
-
\ No newline at end of file
diff --git a/app/dashboard/templates/conversations.html b/app/dashboard/templates/conversations.html
deleted file mode 100644
index f9b1ef2..0000000
--- a/app/dashboard/templates/conversations.html
+++ /dev/null
@@ -1,334 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Conversations - Claude Code Project Tracker{% endblock %}
-
-{% block content %}
-
-
-
-
-
- Conversation History
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Search through your conversation history with Claude Code
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Search Your Conversations
-
Enter a search term to find relevant conversations with Claude.
-
-
-
-
-
-
-{% endblock %}
-
-{% block scripts %}
-
-{% endblock %}
\ No newline at end of file
diff --git a/app/dashboard/templates/dashboard.html b/app/dashboard/templates/dashboard.html
deleted file mode 100644
index 8b6ea16..0000000
--- a/app/dashboard/templates/dashboard.html
+++ /dev/null
@@ -1,207 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Dashboard - Claude Code Project Tracker{% endblock %}
-
-{% block content %}
-
-
-
-
-
- Development Dashboard
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Total Sessions
- -
-
-
-
-
-
-
-
-
-
-
-
-
-
Development Time
- -
- hours
-
-
-
-
-
-
-
-
-
-
-
-
-
Active Projects
- -
-
-
-
-
-
-
-
-
-
-
-
-
-
Productivity Score
- -
- out of 100
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Engagement Score
-
Based on think times and response patterns
-
-
-
-
-
-
-
Avg Session Length
-
minutes per development session
-
-
-
-
-
-
-
Think Time
-
average seconds between interactions
-
-
-
-
-
-
-
-{% endblock %}
-
-{% block scripts %}
-
-
-{% endblock %}
\ No newline at end of file
diff --git a/app/dashboard/templates/projects.html b/app/dashboard/templates/projects.html
deleted file mode 100644
index b313df7..0000000
--- a/app/dashboard/templates/projects.html
+++ /dev/null
@@ -1,192 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Projects - Claude Code Project Tracker{% endblock %}
-
-{% block content %}
-
-
-
-
-
- Projects Overview
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Loading...
-
-
Loading projects...
-
-
-
-
-
-
-{% endblock %}
-
-{% block scripts %}
-
-{% endblock %}
\ No newline at end of file
diff --git a/app/database/__init__.py b/app/database/__init__.py
deleted file mode 100644
index 0003ac8..0000000
--- a/app/database/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""
-Database connection and initialization for Claude Code Project Tracker.
-"""
-
-from .connection import get_db, get_engine, init_database
-
-__all__ = ["get_db", "get_engine", "init_database"]
\ No newline at end of file
diff --git a/app/database/connection.py b/app/database/connection.py
deleted file mode 100644
index 4dcc8c4..0000000
--- a/app/database/connection.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""
-Database connection management for the Claude Code Project Tracker.
-"""
-
-import os
-from typing import AsyncGenerator
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
-from sqlalchemy.pool import StaticPool
-
-from app.models.base import Base
-
-# Database configuration
-DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./data/tracker.db")
-
-# Create async engine
-engine = create_async_engine(
- DATABASE_URL,
- echo=os.getenv("DEBUG", "false").lower() == "true", # Log SQL queries in debug mode
- connect_args={"check_same_thread": False} if "sqlite" in DATABASE_URL else {},
- poolclass=StaticPool if "sqlite" in DATABASE_URL else None,
-)
-
-# Create session factory
-async_session_maker = async_sessionmaker(
- engine,
- class_=AsyncSession,
- expire_on_commit=False
-)
-
-
-async def get_db() -> AsyncGenerator[AsyncSession, None]:
- """
- Dependency function to get database session.
-
- Used by FastAPI dependency injection to provide database sessions
- to route handlers.
- """
- async with async_session_maker() as session:
- try:
- yield session
- except Exception:
- await session.rollback()
- raise
- finally:
- await session.close()
-
-
-def get_engine():
- """Get the database engine."""
- return engine
-
-
-async def init_database():
- """Initialize the database by creating all tables."""
- async with engine.begin() as conn:
- # Import all models to ensure they're registered
- from app.models import (
- Project, Session, Conversation, Activity,
- WaitingPeriod, GitOperation
- )
-
- # Create all tables
- await conn.run_sync(Base.metadata.create_all)
-
- print("Database initialized successfully!")
-
-
-async def close_database():
- """Close database connections."""
- await engine.dispose()
- print("Database connections closed.")
\ No newline at end of file
diff --git a/app/database/init_db.py b/app/database/init_db.py
deleted file mode 100644
index 02f071f..0000000
--- a/app/database/init_db.py
+++ /dev/null
@@ -1,24 +0,0 @@
-"""
-Database initialization script.
-"""
-
-import asyncio
-import os
-from pathlib import Path
-
-from app.database.connection import init_database
-
-
-async def main():
- """Initialize the database."""
- # Ensure data directory exists
- data_dir = Path("data")
- data_dir.mkdir(exist_ok=True)
-
- print("Initializing Claude Code Project Tracker database...")
- await init_database()
- print("Database initialization complete!")
-
-
-if __name__ == "__main__":
- asyncio.run(main())
\ No newline at end of file
diff --git a/app/models/__init__.py b/app/models/__init__.py
deleted file mode 100644
index c0af4f1..0000000
--- a/app/models/__init__.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""
-Database models for the Claude Code Project Tracker.
-"""
-
-from .base import Base
-from .project import Project
-from .session import Session
-from .conversation import Conversation
-from .activity import Activity
-from .waiting_period import WaitingPeriod
-from .git_operation import GitOperation
-
-__all__ = [
- "Base",
- "Project",
- "Session",
- "Conversation",
- "Activity",
- "WaitingPeriod",
- "GitOperation",
-]
\ No newline at end of file
diff --git a/app/models/activity.py b/app/models/activity.py
deleted file mode 100644
index 8412b74..0000000
--- a/app/models/activity.py
+++ /dev/null
@@ -1,162 +0,0 @@
-"""
-Activity model for tracking tool usage and file operations.
-"""
-
-from datetime import datetime
-from typing import Optional, Dict, Any
-from sqlalchemy import String, Text, Integer, DateTime, JSON, ForeignKey, Boolean
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from .base import Base, TimestampMixin
-
-
-class Activity(Base, TimestampMixin):
- """
- Represents a single tool usage or file operation during development.
-
- Activities are generated by Claude Code tool usage and provide
- detailed insight into the development workflow.
- """
-
- __tablename__ = "activities"
-
- # Primary key
- id: Mapped[int] = mapped_column(primary_key=True)
-
- # Foreign keys
- session_id: Mapped[int] = mapped_column(ForeignKey("sessions.id"), nullable=False, index=True)
- conversation_id: Mapped[Optional[int]] = mapped_column(
- ForeignKey("conversations.id"),
- nullable=True,
- index=True
- )
-
- # Activity timing
- timestamp: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- nullable=False,
- default=func.now(),
- index=True
- )
-
- # Activity details
- tool_name: Mapped[str] = mapped_column(String(50), nullable=False, index=True)
- action: Mapped[str] = mapped_column(String(100), nullable=False)
- file_path: Mapped[Optional[str]] = mapped_column(Text, nullable=True, index=True)
-
- # Metadata and results
- metadata: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSON, nullable=True)
- success: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
- error_message: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-
- # Code change metrics (for Edit/Write operations)
- lines_added: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
- lines_removed: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
-
- # Relationships
- session: Mapped["Session"] = relationship("Session", back_populates="activities")
- conversation: Mapped[Optional["Conversation"]] = relationship(
- "Conversation",
- foreign_keys=[conversation_id]
- )
-
- def __repr__(self) -> str:
- file_info = f", file='{self.file_path}'" if self.file_path else ""
- return f""
-
- @property
- def is_file_operation(self) -> bool:
- """Check if this activity involves file operations."""
- return self.tool_name in {"Edit", "Write", "Read"}
-
- @property
- def is_code_execution(self) -> bool:
- """Check if this activity involves code/command execution."""
- return self.tool_name in {"Bash", "Task"}
-
- @property
- def is_search_operation(self) -> bool:
- """Check if this activity involves searching."""
- return self.tool_name in {"Grep", "Glob"}
-
- @property
- def total_lines_changed(self) -> int:
- """Get total lines changed (added + removed)."""
- added = self.lines_added or 0
- removed = self.lines_removed or 0
- return added + removed
-
- @property
- def net_lines_changed(self) -> int:
- """Get net lines changed (added - removed)."""
- added = self.lines_added or 0
- removed = self.lines_removed or 0
- return added - removed
-
- def get_file_extension(self) -> Optional[str]:
- """Extract file extension from file path."""
- if not self.file_path:
- return None
-
- if "." in self.file_path:
- return self.file_path.split(".")[-1].lower()
- return None
-
- def get_programming_language(self) -> Optional[str]:
- """Infer programming language from file extension."""
- ext = self.get_file_extension()
- if not ext:
- return None
-
- language_map = {
- "py": "python",
- "js": "javascript",
- "ts": "typescript",
- "jsx": "javascript",
- "tsx": "typescript",
- "go": "go",
- "rs": "rust",
- "java": "java",
- "cpp": "cpp",
- "c": "c",
- "h": "c",
- "hpp": "cpp",
- "rb": "ruby",
- "php": "php",
- "html": "html",
- "css": "css",
- "scss": "scss",
- "sql": "sql",
- "md": "markdown",
- "yml": "yaml",
- "yaml": "yaml",
- "json": "json",
- "xml": "xml",
- "sh": "shell",
- "bash": "shell",
- }
-
- return language_map.get(ext)
-
- def is_successful(self) -> bool:
- """Check if the activity completed successfully."""
- return self.success and not self.error_message
-
- def get_command_executed(self) -> Optional[str]:
- """Get the command that was executed (for Bash activities)."""
- if self.tool_name == "Bash" and self.metadata:
- return self.metadata.get("command")
- return None
-
- def get_search_pattern(self) -> Optional[str]:
- """Get the search pattern (for Grep activities)."""
- if self.tool_name == "Grep" and self.metadata:
- return self.metadata.get("pattern")
- return None
-
- def get_task_type(self) -> Optional[str]:
- """Get the task type (for Task activities)."""
- if self.tool_name == "Task" and self.metadata:
- return self.metadata.get("task_type")
- return None
\ No newline at end of file
diff --git a/app/models/base.py b/app/models/base.py
deleted file mode 100644
index 25b464c..0000000
--- a/app/models/base.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""
-Base model configuration for SQLAlchemy models.
-"""
-
-from datetime import datetime
-from typing import Any
-from sqlalchemy import DateTime
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-from sqlalchemy.sql import func
-
-
-class Base(DeclarativeBase):
- """Base class for all database models."""
- pass
-
-
-class TimestampMixin:
- """Mixin to add created_at and updated_at timestamps to models."""
-
- created_at: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- server_default=func.now(),
- nullable=False
- )
-
- updated_at: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- server_default=func.now(),
- onupdate=func.now(),
- nullable=False
- )
\ No newline at end of file
diff --git a/app/models/conversation.py b/app/models/conversation.py
deleted file mode 100644
index 4bc8d88..0000000
--- a/app/models/conversation.py
+++ /dev/null
@@ -1,118 +0,0 @@
-"""
-Conversation model for tracking dialogue between user and Claude.
-"""
-
-from datetime import datetime
-from typing import Optional, List, Dict, Any
-from sqlalchemy import String, Text, Integer, DateTime, JSON, ForeignKey
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from .base import Base, TimestampMixin
-
-
-class Conversation(Base, TimestampMixin):
- """
- Represents a conversation exchange between user and Claude.
-
- Each conversation entry captures either a user prompt or Claude's response,
- along with context about tools used and files affected.
- """
-
- __tablename__ = "conversations"
-
- # Primary key
- id: Mapped[int] = mapped_column(primary_key=True)
-
- # Foreign key to session
- session_id: Mapped[int] = mapped_column(ForeignKey("sessions.id"), nullable=False, index=True)
-
- # Timing
- timestamp: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- nullable=False,
- default=func.now(),
- index=True
- )
-
- # Conversation content
- user_prompt: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
- claude_response: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-
- # Context and metadata
- tools_used: Mapped[Optional[List[str]]] = mapped_column(JSON, nullable=True)
- files_affected: Mapped[Optional[List[str]]] = mapped_column(JSON, nullable=True)
- context: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSON, nullable=True)
-
- # Token estimates for analysis
- tokens_input: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
- tokens_output: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
-
- # Exchange type for categorization
- exchange_type: Mapped[str] = mapped_column(String(50), nullable=False) # user_prompt, claude_response
-
- # Relationships
- session: Mapped["Session"] = relationship("Session", back_populates="conversations")
-
- def __repr__(self) -> str:
- content_preview = ""
- if self.user_prompt:
- content_preview = self.user_prompt[:50] + "..." if len(self.user_prompt) > 50 else self.user_prompt
- elif self.claude_response:
- content_preview = self.claude_response[:50] + "..." if len(self.claude_response) > 50 else self.claude_response
-
- return f""
-
- @property
- def is_user_prompt(self) -> bool:
- """Check if this is a user prompt."""
- return self.exchange_type == "user_prompt"
-
- @property
- def is_claude_response(self) -> bool:
- """Check if this is a Claude response."""
- return self.exchange_type == "claude_response"
-
- @property
- def content_length(self) -> int:
- """Get the total character length of the conversation content."""
- user_length = len(self.user_prompt) if self.user_prompt else 0
- claude_length = len(self.claude_response) if self.claude_response else 0
- return user_length + claude_length
-
- @property
- def estimated_tokens(self) -> int:
- """Estimate total tokens in this conversation exchange."""
- if self.tokens_input and self.tokens_output:
- return self.tokens_input + self.tokens_output
-
- # Rough estimation: ~4 characters per token
- return self.content_length // 4
-
- def get_intent_category(self) -> Optional[str]:
- """Extract intent category from context if available."""
- if self.context and "intent" in self.context:
- return self.context["intent"]
- return None
-
- def get_complexity_level(self) -> Optional[str]:
- """Extract complexity level from context if available."""
- if self.context and "complexity" in self.context:
- return self.context["complexity"]
- return None
-
- def has_file_operations(self) -> bool:
- """Check if this conversation involved file operations."""
- if not self.tools_used:
- return False
-
- file_tools = {"Edit", "Write", "Read"}
- return any(tool in file_tools for tool in self.tools_used)
-
- def has_code_execution(self) -> bool:
- """Check if this conversation involved code execution."""
- if not self.tools_used:
- return False
-
- execution_tools = {"Bash", "Task"}
- return any(tool in execution_tools for tool in self.tools_used)
\ No newline at end of file
diff --git a/app/models/git_operation.py b/app/models/git_operation.py
deleted file mode 100644
index 2cf470c..0000000
--- a/app/models/git_operation.py
+++ /dev/null
@@ -1,202 +0,0 @@
-"""
-Git operation model for tracking repository changes.
-"""
-
-from datetime import datetime
-from typing import Optional, List
-from sqlalchemy import String, Text, Integer, DateTime, JSON, ForeignKey, Boolean
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from .base import Base, TimestampMixin
-
-
-class GitOperation(Base, TimestampMixin):
- """
- Represents a git operation performed during a development session.
-
- Tracks commits, pushes, pulls, branch operations, and other git commands
- to provide insight into version control workflow.
- """
-
- __tablename__ = "git_operations"
-
- # Primary key
- id: Mapped[int] = mapped_column(primary_key=True)
-
- # Foreign key to session
- session_id: Mapped[int] = mapped_column(ForeignKey("sessions.id"), nullable=False, index=True)
-
- # Operation timing
- timestamp: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- nullable=False,
- default=func.now(),
- index=True
- )
-
- # Operation details
- operation: Mapped[str] = mapped_column(String(50), nullable=False, index=True) # commit, push, pull, branch, etc.
- command: Mapped[str] = mapped_column(Text, nullable=False)
- result: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
- success: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
-
- # File and change tracking
- files_changed: Mapped[Optional[List[str]]] = mapped_column(JSON, nullable=True)
- lines_added: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
- lines_removed: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
-
- # Commit-specific fields
- commit_hash: Mapped[Optional[str]] = mapped_column(String(40), nullable=True, index=True)
-
- # Branch operation fields
- branch_from: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
- branch_to: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
-
- # Relationships
- session: Mapped["Session"] = relationship("Session", back_populates="git_operations")
-
- def __repr__(self) -> str:
- return f""
-
- @property
- def is_commit(self) -> bool:
- """Check if this is a commit operation."""
- return self.operation == "commit"
-
- @property
- def is_push(self) -> bool:
- """Check if this is a push operation."""
- return self.operation == "push"
-
- @property
- def is_pull(self) -> bool:
- """Check if this is a pull operation."""
- return self.operation == "pull"
-
- @property
- def is_branch_operation(self) -> bool:
- """Check if this is a branch-related operation."""
- return self.operation in {"branch", "checkout", "merge", "rebase"}
-
- @property
- def total_lines_changed(self) -> int:
- """Get total lines changed (added + removed)."""
- added = self.lines_added or 0
- removed = self.lines_removed or 0
- return added + removed
-
- @property
- def net_lines_changed(self) -> int:
- """Get net lines changed (added - removed)."""
- added = self.lines_added or 0
- removed = self.lines_removed or 0
- return added - removed
-
- @property
- def files_count(self) -> int:
- """Get number of files changed."""
- return len(self.files_changed) if self.files_changed else 0
-
- def get_commit_message(self) -> Optional[str]:
- """Extract commit message from the command."""
- if not self.is_commit:
- return None
-
- command = self.command
- if "-m" in command:
- # Extract message between quotes after -m
- parts = command.split("-m")
- if len(parts) > 1:
- message_part = parts[1].strip()
- # Remove quotes
- if message_part.startswith('"') and message_part.endswith('"'):
- return message_part[1:-1]
- elif message_part.startswith("'") and message_part.endswith("'"):
- return message_part[1:-1]
- else:
- # Find first quoted string
- import re
- match = re.search(r'["\']([^"\']*)["\']', message_part)
- if match:
- return match.group(1)
-
- return None
-
- def get_branch_name(self) -> Optional[str]:
- """Get branch name for branch operations."""
- if self.branch_to:
- return self.branch_to
- elif self.branch_from:
- return self.branch_from
-
- # Try to extract from command
- if "checkout" in self.command:
- parts = self.command.split()
- if len(parts) > 2:
- return parts[-1] # Last argument is usually the branch
-
- return None
-
- def is_merge_commit(self) -> bool:
- """Check if this is a merge commit."""
- commit_msg = self.get_commit_message()
- return commit_msg is not None and "merge" in commit_msg.lower()
-
- def is_feature_commit(self) -> bool:
- """Check if this appears to be a feature commit."""
- commit_msg = self.get_commit_message()
- if not commit_msg:
- return False
-
- feature_keywords = ["add", "implement", "create", "new", "feature"]
- return any(keyword in commit_msg.lower() for keyword in feature_keywords)
-
- def is_bugfix_commit(self) -> bool:
- """Check if this appears to be a bugfix commit."""
- commit_msg = self.get_commit_message()
- if not commit_msg:
- return False
-
- bugfix_keywords = ["fix", "bug", "resolve", "correct", "patch"]
- return any(keyword in commit_msg.lower() for keyword in bugfix_keywords)
-
- def is_refactor_commit(self) -> bool:
- """Check if this appears to be a refactoring commit."""
- commit_msg = self.get_commit_message()
- if not commit_msg:
- return False
-
- refactor_keywords = ["refactor", "cleanup", "improve", "optimize", "reorganize"]
- return any(keyword in commit_msg.lower() for keyword in refactor_keywords)
-
- def get_commit_category(self) -> str:
- """Categorize the commit based on its message."""
- if not self.is_commit:
- return "non-commit"
-
- if self.is_merge_commit():
- return "merge"
- elif self.is_feature_commit():
- return "feature"
- elif self.is_bugfix_commit():
- return "bugfix"
- elif self.is_refactor_commit():
- return "refactor"
- else:
- return "other"
-
- def get_change_size_category(self) -> str:
- """Categorize the size of changes in this operation."""
- total_changes = self.total_lines_changed
-
- if total_changes == 0:
- return "no-changes"
- elif total_changes < 10:
- return "small"
- elif total_changes < 50:
- return "medium"
- elif total_changes < 200:
- return "large"
- else:
- return "very-large"
\ No newline at end of file
diff --git a/app/models/project.py b/app/models/project.py
deleted file mode 100644
index 18f544c..0000000
--- a/app/models/project.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""
-Project model for tracking development projects.
-"""
-
-from datetime import datetime
-from typing import Optional, List
-from sqlalchemy import String, Text, Integer, DateTime, JSON
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from .base import Base, TimestampMixin
-
-
-class Project(Base, TimestampMixin):
- """
- Represents a development project tracked by Claude Code.
-
- A project is typically identified by its filesystem path and may
- correspond to a git repository.
- """
-
- __tablename__ = "projects"
-
- # Primary key
- id: Mapped[int] = mapped_column(primary_key=True)
-
- # Core project information
- name: Mapped[str] = mapped_column(String(255), nullable=False)
- path: Mapped[str] = mapped_column(Text, nullable=False, unique=True, index=True)
- git_repo: Mapped[Optional[str]] = mapped_column(String(500), nullable=True)
- languages: Mapped[Optional[List[str]]] = mapped_column(JSON, nullable=True)
-
- # Activity tracking
- last_session: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True, index=True)
- total_sessions: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
- total_time_minutes: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
- files_modified_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
- lines_changed_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
-
- # Relationships
- sessions: Mapped[List["Session"]] = relationship(
- "Session",
- back_populates="project",
- cascade="all, delete-orphan",
- order_by="Session.start_time.desc()"
- )
-
- def __repr__(self) -> str:
- return f""
-
- @property
- def is_git_repo(self) -> bool:
- """Check if this project is a git repository."""
- return self.git_repo is not None and self.git_repo != ""
-
- @property
- def primary_language(self) -> Optional[str]:
- """Get the primary programming language for this project."""
- if self.languages and len(self.languages) > 0:
- return self.languages[0]
- return None
-
- def update_stats(self, session_duration_minutes: int, files_count: int, lines_count: int) -> None:
- """Update project statistics after a session."""
- self.total_sessions += 1
- self.total_time_minutes += session_duration_minutes
- self.files_modified_count += files_count
- self.lines_changed_count += lines_count
- self.last_session = func.now()
\ No newline at end of file
diff --git a/app/models/session.py b/app/models/session.py
deleted file mode 100644
index cd0e2d7..0000000
--- a/app/models/session.py
+++ /dev/null
@@ -1,134 +0,0 @@
-"""
-Session model for tracking individual development sessions.
-"""
-
-from datetime import datetime
-from typing import Optional, List, Dict, Any
-from sqlalchemy import String, Text, Integer, DateTime, JSON, ForeignKey, Boolean
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from .base import Base, TimestampMixin
-
-
-class Session(Base, TimestampMixin):
- """
- Represents an individual development session within a project.
-
- A session starts when Claude Code is launched or resumed and ends
- when the user stops or the session is interrupted.
- """
-
- __tablename__ = "sessions"
-
- # Primary key
- id: Mapped[int] = mapped_column(primary_key=True)
-
- # Foreign key to project
- project_id: Mapped[int] = mapped_column(ForeignKey("projects.id"), nullable=False, index=True)
-
- # Session timing
- start_time: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- nullable=False,
- default=func.now(),
- index=True
- )
- end_time: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True)
-
- # Session metadata
- session_type: Mapped[str] = mapped_column(String(50), nullable=False) # startup, resume, clear
- working_directory: Mapped[str] = mapped_column(Text, nullable=False)
- git_branch: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
- environment: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSON, nullable=True)
-
- # Session statistics (updated as session progresses)
- duration_minutes: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
- activity_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
- conversation_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
- files_touched: Mapped[Optional[List[str]]] = mapped_column(JSON, nullable=True)
-
- # Relationships
- project: Mapped["Project"] = relationship("Project", back_populates="sessions")
- conversations: Mapped[List["Conversation"]] = relationship(
- "Conversation",
- back_populates="session",
- cascade="all, delete-orphan",
- order_by="Conversation.timestamp"
- )
- activities: Mapped[List["Activity"]] = relationship(
- "Activity",
- back_populates="session",
- cascade="all, delete-orphan",
- order_by="Activity.timestamp"
- )
- waiting_periods: Mapped[List["WaitingPeriod"]] = relationship(
- "WaitingPeriod",
- back_populates="session",
- cascade="all, delete-orphan",
- order_by="WaitingPeriod.start_time"
- )
- git_operations: Mapped[List["GitOperation"]] = relationship(
- "GitOperation",
- back_populates="session",
- cascade="all, delete-orphan",
- order_by="GitOperation.timestamp"
- )
-
- def __repr__(self) -> str:
- return f""
-
- @property
- def is_active(self) -> bool:
- """Check if this session is still active (not ended)."""
- return self.end_time is None
-
- @property
- def calculated_duration_minutes(self) -> Optional[int]:
- """Calculate session duration in minutes."""
- if self.end_time is None:
- # Session is still active, calculate current duration
- current_duration = datetime.utcnow() - self.start_time
- return int(current_duration.total_seconds() / 60)
- else:
- # Session is finished
- if self.duration_minutes is not None:
- return self.duration_minutes
- else:
- duration = self.end_time - self.start_time
- return int(duration.total_seconds() / 60)
-
- def end_session(self, end_reason: str = "normal") -> None:
- """End the session and calculate final statistics."""
- if self.end_time is None:
- self.end_time = func.now()
- self.duration_minutes = self.calculated_duration_minutes
-
- # Update project statistics
- if self.project:
- unique_files = len(set(self.files_touched or []))
- total_lines = sum(
- (activity.lines_added or 0) + (activity.lines_removed or 0)
- for activity in self.activities
- )
- self.project.update_stats(
- session_duration_minutes=self.duration_minutes or 0,
- files_count=unique_files,
- lines_count=total_lines
- )
-
- def add_activity(self) -> None:
- """Increment activity counter."""
- self.activity_count += 1
-
- def add_conversation(self) -> None:
- """Increment conversation counter."""
- self.conversation_count += 1
-
- def add_file_touched(self, file_path: str) -> None:
- """Add a file to the list of files touched in this session."""
- if self.files_touched is None:
- self.files_touched = []
-
- if file_path not in self.files_touched:
- self.files_touched.append(file_path)
\ No newline at end of file
diff --git a/app/models/waiting_period.py b/app/models/waiting_period.py
deleted file mode 100644
index 2db0948..0000000
--- a/app/models/waiting_period.py
+++ /dev/null
@@ -1,156 +0,0 @@
-"""
-Waiting period model for tracking think time and engagement.
-"""
-
-from datetime import datetime
-from typing import Optional
-from sqlalchemy import String, Text, Integer, DateTime, ForeignKey
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.sql import func
-
-from .base import Base, TimestampMixin
-
-
-class WaitingPeriod(Base, TimestampMixin):
- """
- Represents a period when Claude is waiting for user input.
-
- These periods provide insight into user thinking time, engagement patterns,
- and workflow interruptions during development sessions.
- """
-
- __tablename__ = "waiting_periods"
-
- # Primary key
- id: Mapped[int] = mapped_column(primary_key=True)
-
- # Foreign key to session
- session_id: Mapped[int] = mapped_column(ForeignKey("sessions.id"), nullable=False, index=True)
-
- # Timing
- start_time: Mapped[datetime] = mapped_column(
- DateTime(timezone=True),
- nullable=False,
- default=func.now(),
- index=True
- )
- end_time: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True)
- duration_seconds: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, index=True)
-
- # Context
- context_before: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
- context_after: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-
- # Activity inference
- likely_activity: Mapped[Optional[str]] = mapped_column(String(50), nullable=True) # thinking, research, external_work, break
-
- # Relationships
- session: Mapped["Session"] = relationship("Session", back_populates="waiting_periods")
-
- def __repr__(self) -> str:
- duration_info = f", duration={self.duration_seconds}s" if self.duration_seconds else ""
- return f""
-
- @property
- def is_active(self) -> bool:
- """Check if this waiting period is still active (not ended)."""
- return self.end_time is None
-
- @property
- def calculated_duration_seconds(self) -> Optional[int]:
- """Calculate waiting period duration in seconds."""
- if self.end_time is None:
- # Still waiting, calculate current duration
- current_duration = datetime.utcnow() - self.start_time
- return int(current_duration.total_seconds())
- else:
- # Finished waiting
- if self.duration_seconds is not None:
- return self.duration_seconds
- else:
- duration = self.end_time - self.start_time
- return int(duration.total_seconds())
-
- @property
- def duration_minutes(self) -> Optional[float]:
- """Get duration in minutes."""
- seconds = self.calculated_duration_seconds
- return seconds / 60 if seconds is not None else None
-
- def end_waiting(self, context_after: Optional[str] = None) -> None:
- """End the waiting period and calculate duration."""
- if self.end_time is None:
- self.end_time = func.now()
- self.duration_seconds = self.calculated_duration_seconds
- if context_after:
- self.context_after = context_after
-
- def classify_activity(self) -> str:
- """
- Classify the likely activity based on duration and context.
-
- Returns one of: 'thinking', 'research', 'external_work', 'break'
- """
- if self.likely_activity:
- return self.likely_activity
-
- duration = self.calculated_duration_seconds
- if duration is None:
- return "unknown"
-
- # Classification based on duration
- if duration < 10:
- return "thinking" # Quick pause
- elif duration < 60:
- return "thinking" # Short contemplation
- elif duration < 300: # 5 minutes
- return "research" # Looking something up
- elif duration < 1800: # 30 minutes
- return "external_work" # Working on something else
- else:
- return "break" # Extended break
-
- @property
- def engagement_score(self) -> float:
- """
- Calculate an engagement score based on waiting time.
-
- Returns a score from 0.0 (disengaged) to 1.0 (highly engaged).
- """
- duration = self.calculated_duration_seconds
- if duration is None:
- return 0.5 # Default neutral score
-
- # Short waits indicate high engagement
- if duration <= 5:
- return 1.0
- elif duration <= 30:
- return 0.9
- elif duration <= 120: # 2 minutes
- return 0.7
- elif duration <= 300: # 5 minutes
- return 0.5
- elif duration <= 900: # 15 minutes
- return 0.3
- else:
- return 0.1 # Long waits indicate low engagement
-
- def is_quick_response(self) -> bool:
- """Check if user responded quickly (< 30 seconds)."""
- duration = self.calculated_duration_seconds
- return duration is not None and duration < 30
-
- def is_thoughtful_pause(self) -> bool:
- """Check if this was a thoughtful pause (30s - 2 minutes)."""
- duration = self.calculated_duration_seconds
- return duration is not None and 30 <= duration < 120
-
- def is_research_break(self) -> bool:
- """Check if this was likely a research break (2 - 15 minutes)."""
- duration = self.calculated_duration_seconds
- return duration is not None and 120 <= duration < 900
-
- def is_extended_break(self) -> bool:
- """Check if this was an extended break (> 15 minutes)."""
- duration = self.calculated_duration_seconds
- return duration is not None and duration >= 900
\ No newline at end of file
diff --git a/config/claude-hooks.json b/config/claude-hooks.json
deleted file mode 100644
index d8de1ff..0000000
--- a/config/claude-hooks.json
+++ /dev/null
@@ -1,63 +0,0 @@
-{
- "hooks": {
- "SessionStart": [
- {
- "matcher": "startup",
- "command": "curl -s -X POST http://localhost:8000/api/session/start -H 'Content-Type: application/json' -d '{\"session_type\":\"startup\",\"working_directory\":\"'\"$PWD\"'\",\"git_branch\":\"'$(git branch --show-current 2>/dev/null || echo \"unknown\")'\",\"git_repo\":\"'$(git config --get remote.origin.url 2>/dev/null || echo \"null\")'\",\"environment\":{\"pwd\":\"'\"$PWD\"'\",\"user\":\"'\"$USER\"'\",\"timestamp\":\"'$(date -Iseconds)'\"}}' > /dev/null 2>&1 &"
- },
- {
- "matcher": "resume",
- "command": "curl -s -X POST http://localhost:8000/api/session/start -H 'Content-Type: application/json' -d '{\"session_type\":\"resume\",\"working_directory\":\"'\"$PWD\"'\",\"git_branch\":\"'$(git branch --show-current 2>/dev/null || echo \"unknown\")'\",\"git_repo\":\"'$(git config --get remote.origin.url 2>/dev/null || echo \"null\")'\",\"environment\":{\"pwd\":\"'\"$PWD\"'\",\"user\":\"'\"$USER\"'\",\"timestamp\":\"'$(date -Iseconds)'\"}}' > /dev/null 2>&1 &"
- },
- {
- "matcher": "clear",
- "command": "curl -s -X POST http://localhost:8000/api/session/start -H 'Content-Type: application/json' -d '{\"session_type\":\"clear\",\"working_directory\":\"'\"$PWD\"'\",\"git_branch\":\"'$(git branch --show-current 2>/dev/null || echo \"unknown\")'\",\"git_repo\":\"'$(git config --get remote.origin.url 2>/dev/null || echo \"null\")'\",\"environment\":{\"pwd\":\"'\"$PWD\"'\",\"user\":\"'\"$USER\"'\",\"timestamp\":\"'$(date -Iseconds)'\"}}' > /dev/null 2>&1 &"
- }
- ],
- "UserPromptSubmit": [
- {
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"timestamp\":\"'$(date -Iseconds)'\",\"user_prompt\":\"'$(echo \"$CLAUDE_USER_PROMPT\" | sed 's/\"/\\\\\"/g' | tr '\\n' ' ')'\",\"exchange_type\":\"user_prompt\"}' | curl -s -X POST http://localhost:8000/api/conversation -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- }
- ],
- "Notification": [
- {
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); curl -s -X POST http://localhost:8000/api/waiting/start -H 'Content-Type: application/json' -d '{\"session_id\":'$SESSION_ID',\"timestamp\":\"'$(date -Iseconds)'\",\"context_before\":\"Claude is waiting for input\"}' > /dev/null 2>&1 &"
- }
- ],
- "PostToolUse": [
- {
- "matcher": "Edit",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Edit\",\"action\":\"file_edit\",\"file_path\":\"'\"$CLAUDE_TOOL_FILE_PATH\"'\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Write",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Write\",\"action\":\"file_write\",\"file_path\":\"'\"$CLAUDE_TOOL_FILE_PATH\"'\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Read",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Read\",\"action\":\"file_read\",\"file_path\":\"'\"$CLAUDE_TOOL_FILE_PATH\"'\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Bash",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); SAFE_COMMAND=$(echo \"$CLAUDE_BASH_COMMAND\" | sed 's/\"/\\\\\"/g' | tr '\\n' ' '); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Bash\",\"action\":\"command_execution\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"command\":\"'$SAFE_COMMAND'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Grep",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); SAFE_PATTERN=$(echo \"$CLAUDE_GREP_PATTERN\" | sed 's/\"/\\\\\"/g'); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Grep\",\"action\":\"search\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"pattern\":\"'$SAFE_PATTERN'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Glob",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Glob\",\"action\":\"file_search\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"pattern\":\"'\"$CLAUDE_GLOB_PATTERN\"'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Task",
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"tool_name\":\"Task\",\"action\":\"subagent_call\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"task_type\":\"'\"$CLAUDE_TASK_TYPE\"'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- }
- ],
- "Stop": [
- {
- "command": "CLAUDE_SESSION_FILE='/tmp/claude-session-id'; SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo '1'); echo '{\"session_id\":'$SESSION_ID',\"timestamp\":\"'$(date -Iseconds)'\",\"claude_response\":\"Response completed\",\"exchange_type\":\"claude_response\"}' | curl -s -X POST http://localhost:8000/api/conversation -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 && curl -s -X POST http://localhost:8000/api/waiting/end -H 'Content-Type: application/json' -d '{\"session_id\":'$SESSION_ID',\"timestamp\":\"'$(date -Iseconds)'\"}' > /dev/null 2>&1 &"
- }
- ]
- }
-}
\ No newline at end of file
diff --git a/docs/api-spec.yaml b/docs/api-spec.yaml
deleted file mode 100644
index c494264..0000000
--- a/docs/api-spec.yaml
+++ /dev/null
@@ -1,530 +0,0 @@
-openapi: 3.0.3
-info:
- title: Claude Code Project Tracker API
- description: |
- REST API for tracking Claude Code development sessions, conversations, and productivity metrics.
-
- This API is designed to be called by Claude Code hooks to automatically capture development workflow data.
- version: 1.0.0
- license:
- name: MIT
-
-servers:
- - url: http://localhost:8000
- description: Local development server
-
-paths:
- # Session Management
- /api/session/start:
- post:
- summary: Start a new development session
- description: Called by SessionStart hook to initialize project tracking
- tags:
- - Sessions
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/SessionStart'
- responses:
- '201':
- description: Session created successfully
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/SessionResponse'
- '400':
- description: Invalid request data
-
- /api/session/end:
- post:
- summary: End current development session
- description: Called by Stop hook to finalize session tracking
- tags:
- - Sessions
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/SessionEnd'
- responses:
- '200':
- description: Session ended successfully
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/SessionResponse'
-
- # Conversation Tracking
- /api/conversation:
- post:
- summary: Log conversation exchange
- description: Called by UserPromptSubmit and Stop hooks to capture dialogue
- tags:
- - Conversations
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/ConversationEntry'
- responses:
- '201':
- description: Conversation logged successfully
-
- # Activity Tracking
- /api/activity:
- post:
- summary: Record development activity
- description: Called by PostToolUse hooks to track tool usage and file operations
- tags:
- - Activities
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/Activity'
- responses:
- '201':
- description: Activity recorded successfully
-
- # Waiting Period Tracking
- /api/waiting/start:
- post:
- summary: Start waiting period
- description: Called by Notification hook when Claude is waiting for input
- tags:
- - Waiting
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/WaitingStart'
- responses:
- '201':
- description: Waiting period started
-
- /api/waiting/end:
- post:
- summary: End waiting period
- description: Called when user submits new input
- tags:
- - Waiting
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/WaitingEnd'
- responses:
- '200':
- description: Waiting period ended
-
- # Git Operations
- /api/git:
- post:
- summary: Record git operation
- description: Track git commands and repository state changes
- tags:
- - Git
- requestBody:
- required: true
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/GitOperation'
- responses:
- '201':
- description: Git operation recorded
-
- # Data Retrieval
- /api/projects:
- get:
- summary: List all tracked projects
- description: Get overview of all projects with summary statistics
- tags:
- - Projects
- parameters:
- - name: limit
- in: query
- schema:
- type: integer
- default: 50
- - name: offset
- in: query
- schema:
- type: integer
- default: 0
- responses:
- '200':
- description: List of projects
- content:
- application/json:
- schema:
- type: array
- items:
- $ref: '#/components/schemas/ProjectSummary'
-
- /api/projects/{project_id}/timeline:
- get:
- summary: Get detailed project timeline
- description: Retrieve chronological history of project development
- tags:
- - Projects
- parameters:
- - name: project_id
- in: path
- required: true
- schema:
- type: integer
- - name: start_date
- in: query
- schema:
- type: string
- format: date
- - name: end_date
- in: query
- schema:
- type: string
- format: date
- responses:
- '200':
- description: Project timeline
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/ProjectTimeline'
-
- # Analytics
- /api/analytics/productivity:
- get:
- summary: Get productivity analytics
- description: Retrieve engagement metrics and output analysis
- tags:
- - Analytics
- parameters:
- - name: project_id
- in: query
- schema:
- type: integer
- - name: days
- in: query
- schema:
- type: integer
- default: 30
- responses:
- '200':
- description: Productivity metrics
- content:
- application/json:
- schema:
- $ref: '#/components/schemas/ProductivityMetrics'
-
- /api/conversations/search:
- get:
- summary: Search conversations
- description: Semantic search through conversation history
- tags:
- - Conversations
- parameters:
- - name: query
- in: query
- required: true
- schema:
- type: string
- - name: project_id
- in: query
- schema:
- type: integer
- - name: limit
- in: query
- schema:
- type: integer
- default: 20
- responses:
- '200':
- description: Search results
- content:
- application/json:
- schema:
- type: array
- items:
- $ref: '#/components/schemas/ConversationSearchResult'
-
-components:
- schemas:
- # Session Schemas
- SessionStart:
- type: object
- required:
- - session_type
- - working_directory
- properties:
- session_type:
- type: string
- enum: [startup, resume, clear]
- working_directory:
- type: string
- git_branch:
- type: string
- git_repo:
- type: string
- environment:
- type: object
-
- SessionEnd:
- type: object
- required:
- - session_id
- properties:
- session_id:
- type: integer
- end_reason:
- type: string
- enum: [normal, interrupted, timeout]
-
- SessionResponse:
- type: object
- properties:
- session_id:
- type: integer
- project_id:
- type: integer
- status:
- type: string
-
- # Conversation Schemas
- ConversationEntry:
- type: object
- required:
- - session_id
- - timestamp
- properties:
- session_id:
- type: integer
- timestamp:
- type: string
- format: date-time
- user_prompt:
- type: string
- claude_response:
- type: string
- tools_used:
- type: array
- items:
- type: string
- files_affected:
- type: array
- items:
- type: string
- context:
- type: object
-
- # Activity Schemas
- Activity:
- type: object
- required:
- - session_id
- - tool_name
- - timestamp
- properties:
- session_id:
- type: integer
- tool_name:
- type: string
- enum: [Edit, Write, Read, Bash, Grep, Glob, Task, WebFetch]
- action:
- type: string
- file_path:
- type: string
- timestamp:
- type: string
- format: date-time
- metadata:
- type: object
- success:
- type: boolean
- error_message:
- type: string
-
- # Waiting Period Schemas
- WaitingStart:
- type: object
- required:
- - session_id
- - timestamp
- properties:
- session_id:
- type: integer
- timestamp:
- type: string
- format: date-time
- context_before:
- type: string
-
- WaitingEnd:
- type: object
- required:
- - session_id
- - timestamp
- properties:
- session_id:
- type: integer
- timestamp:
- type: string
- format: date-time
- duration_seconds:
- type: number
- context_after:
- type: string
-
- # Git Schemas
- GitOperation:
- type: object
- required:
- - session_id
- - operation
- - timestamp
- properties:
- session_id:
- type: integer
- operation:
- type: string
- enum: [commit, push, pull, branch, merge, rebase, status]
- command:
- type: string
- result:
- type: string
- timestamp:
- type: string
- format: date-time
- files_changed:
- type: array
- items:
- type: string
- lines_added:
- type: integer
- lines_removed:
- type: integer
-
- # Response Schemas
- ProjectSummary:
- type: object
- properties:
- id:
- type: integer
- name:
- type: string
- path:
- type: string
- git_repo:
- type: string
- languages:
- type: array
- items:
- type: string
- total_sessions:
- type: integer
- total_time_minutes:
- type: integer
- last_activity:
- type: string
- format: date-time
- files_modified:
- type: integer
- lines_changed:
- type: integer
-
- ProjectTimeline:
- type: object
- properties:
- project:
- $ref: '#/components/schemas/ProjectSummary'
- timeline:
- type: array
- items:
- type: object
- properties:
- timestamp:
- type: string
- format: date-time
- type:
- type: string
- enum: [session_start, session_end, conversation, activity, git_operation]
- data:
- type: object
-
- ProductivityMetrics:
- type: object
- properties:
- engagement_score:
- type: number
- description: Overall engagement level (0-100)
- average_session_length:
- type: number
- description: Minutes per session
- think_time_average:
- type: number
- description: Average waiting time between interactions
- files_per_session:
- type: number
- tools_most_used:
- type: array
- items:
- type: object
- properties:
- tool:
- type: string
- count:
- type: integer
- productivity_trends:
- type: array
- items:
- type: object
- properties:
- date:
- type: string
- format: date
- score:
- type: number
-
- ConversationSearchResult:
- type: object
- properties:
- id:
- type: integer
- project_name:
- type: string
- timestamp:
- type: string
- format: date-time
- user_prompt:
- type: string
- claude_response:
- type: string
- relevance_score:
- type: number
- context:
- type: array
- items:
- type: string
-
-tags:
- - name: Sessions
- description: Development session management
- - name: Conversations
- description: Dialogue tracking and search
- - name: Activities
- description: Tool usage and file operations
- - name: Waiting
- description: Think time and engagement tracking
- - name: Git
- description: Repository operations
- - name: Projects
- description: Project data retrieval
- - name: Analytics
- description: Insights and metrics
\ No newline at end of file
diff --git a/docs/database-schema.md b/docs/database-schema.md
deleted file mode 100644
index cbae636..0000000
--- a/docs/database-schema.md
+++ /dev/null
@@ -1,252 +0,0 @@
-# Database Schema Documentation
-
-This document describes the SQLite database schema for the Claude Code Project Tracker.
-
-## Overview
-
-The database is designed to capture comprehensive development workflow data through a normalized relational structure. All timestamps are stored in UTC format.
-
-## Entity Relationship Diagram
-
-```
-βββββββββββββββ βββββββββββββββ βββββββββββββββ
-β projects β β sessions β βconversationsβ
-β β β β β β
-β id (PK) βββββ€ project_id β β session_id β
-β name β β id (PK) βββββ€ id (PK) β
-β path β β start_time β β timestamp β
-β git_repo β β end_time β β user_prompt β
-β created_at β β type β β claude_resp β
-β ... β β ... β β ... β
-βββββββββββββββ βββββββββββββββ βββββββββββββββ
- β
- β
- βββββββββββββββ βββββββββββββββ
- β activities β βwaiting_perdsβ
- β β β β
- β session_id β β session_id β
- β id (PK) β β id (PK) β
- β tool_name β β start_time β
- β file_path β β end_time β
- β timestamp β β duration β
- β ... β β ... β
- βββββββββββββββ βββββββββββββββ
- β
- β
- βββββββββββββββ
- βgit_operationsβ
- β β
- β session_id β
- β id (PK) β
- β operation β
- β command β
- β timestamp β
- β ... β
- βββββββββββββββ
-```
-
-## Table Definitions
-
-### projects
-
-Stores metadata about tracked projects.
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | INTEGER | PRIMARY KEY | Unique project identifier |
-| name | VARCHAR(255) | NOT NULL | Project display name |
-| path | TEXT | NOT NULL UNIQUE | Absolute filesystem path |
-| git_repo | VARCHAR(500) | NULL | Git repository URL if applicable |
-| languages | JSON | NULL | Array of detected programming languages |
-| created_at | TIMESTAMP | NOT NULL DEFAULT NOW() | First time project was tracked |
-| last_session | TIMESTAMP | NULL | Most recent session timestamp |
-| total_sessions | INTEGER | NOT NULL DEFAULT 0 | Count of development sessions |
-| total_time_minutes | INTEGER | NOT NULL DEFAULT 0 | Cumulative session duration |
-| files_modified_count | INTEGER | NOT NULL DEFAULT 0 | Total unique files changed |
-| lines_changed_count | INTEGER | NOT NULL DEFAULT 0 | Total lines added + removed |
-
-**Indexes:**
-- `idx_projects_path` ON (path)
-- `idx_projects_last_session` ON (last_session)
-
-### sessions
-
-Individual development sessions within projects.
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | INTEGER | PRIMARY KEY | Unique session identifier |
-| project_id | INTEGER | NOT NULL FK(projects.id) | Associated project |
-| start_time | TIMESTAMP | NOT NULL | Session start timestamp |
-| end_time | TIMESTAMP | NULL | Session end timestamp (NULL if active) |
-| session_type | VARCHAR(50) | NOT NULL | startup, resume, clear |
-| working_directory | TEXT | NOT NULL | Directory path when session started |
-| git_branch | VARCHAR(255) | NULL | Active git branch |
-| environment | JSON | NULL | System environment details |
-| duration_minutes | INTEGER | NULL | Calculated session length |
-| activity_count | INTEGER | NOT NULL DEFAULT 0 | Number of tool uses |
-| conversation_count | INTEGER | NOT NULL DEFAULT 0 | Number of exchanges |
-| files_touched | JSON | NULL | Array of file paths accessed |
-
-**Indexes:**
-- `idx_sessions_project_start` ON (project_id, start_time)
-- `idx_sessions_active` ON (end_time) WHERE end_time IS NULL
-
-### conversations
-
-Dialogue exchanges between user and Claude.
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | INTEGER | PRIMARY KEY | Unique conversation identifier |
-| session_id | INTEGER | NOT NULL FK(sessions.id) | Associated session |
-| timestamp | TIMESTAMP | NOT NULL | When exchange occurred |
-| user_prompt | TEXT | NULL | User's input message |
-| claude_response | TEXT | NULL | Claude's response |
-| tools_used | JSON | NULL | Array of tools used in response |
-| files_affected | JSON | NULL | Array of files mentioned/modified |
-| context | JSON | NULL | Additional context metadata |
-| tokens_input | INTEGER | NULL | Estimated input token count |
-| tokens_output | INTEGER | NULL | Estimated output token count |
-| exchange_type | VARCHAR(50) | NOT NULL | user_prompt, claude_response |
-
-**Indexes:**
-- `idx_conversations_session_time` ON (session_id, timestamp)
-- `idx_conversations_search` ON (user_prompt, claude_response) USING fts5
-
-### activities
-
-Tool usage and file operations during development.
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | INTEGER | PRIMARY KEY | Unique activity identifier |
-| session_id | INTEGER | NOT NULL FK(sessions.id) | Associated session |
-| conversation_id | INTEGER | NULL FK(conversations.id) | Associated exchange |
-| timestamp | TIMESTAMP | NOT NULL | When activity occurred |
-| tool_name | VARCHAR(50) | NOT NULL | Edit, Write, Read, Bash, etc. |
-| action | VARCHAR(100) | NOT NULL | Specific action taken |
-| file_path | TEXT | NULL | Target file path if applicable |
-| metadata | JSON | NULL | Tool-specific data |
-| success | BOOLEAN | NOT NULL DEFAULT true | Whether operation succeeded |
-| error_message | TEXT | NULL | Error details if failed |
-| lines_added | INTEGER | NULL | Lines added (for Edit/Write) |
-| lines_removed | INTEGER | NULL | Lines removed (for Edit) |
-
-**Indexes:**
-- `idx_activities_session_time` ON (session_id, timestamp)
-- `idx_activities_tool_file` ON (tool_name, file_path)
-
-### waiting_periods
-
-Time intervals when Claude is waiting for user input.
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | INTEGER | PRIMARY KEY | Unique waiting period identifier |
-| session_id | INTEGER | NOT NULL FK(sessions.id) | Associated session |
-| start_time | TIMESTAMP | NOT NULL | When waiting began |
-| end_time | TIMESTAMP | NULL | When user responded |
-| duration_seconds | INTEGER | NULL | Calculated wait duration |
-| context_before | TEXT | NULL | Claude's last message |
-| context_after | TEXT | NULL | User's next message |
-| likely_activity | VARCHAR(50) | NULL | thinking, research, external_work, break |
-
-**Indexes:**
-- `idx_waiting_session_start` ON (session_id, start_time)
-- `idx_waiting_duration` ON (duration_seconds)
-
-### git_operations
-
-Git commands and repository state changes.
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | INTEGER | PRIMARY KEY | Unique git operation identifier |
-| session_id | INTEGER | NOT NULL FK(sessions.id) | Associated session |
-| timestamp | TIMESTAMP | NOT NULL | When operation occurred |
-| operation | VARCHAR(50) | NOT NULL | commit, push, pull, branch, etc. |
-| command | TEXT | NOT NULL | Full git command executed |
-| result | TEXT | NULL | Command output |
-| success | BOOLEAN | NOT NULL | Whether command succeeded |
-| files_changed | JSON | NULL | Array of affected files |
-| lines_added | INTEGER | NULL | Lines added in commit |
-| lines_removed | INTEGER | NULL | Lines removed in commit |
-| commit_hash | VARCHAR(40) | NULL | Git commit SHA |
-| branch_from | VARCHAR(255) | NULL | Source branch |
-| branch_to | VARCHAR(255) | NULL | Target branch |
-
-**Indexes:**
-- `idx_git_session_time` ON (session_id, timestamp)
-- `idx_git_operation` ON (operation)
-- `idx_git_commit` ON (commit_hash)
-
-## Analytics Views
-
-### project_productivity_summary
-
-Aggregated productivity metrics per project.
-
-```sql
-CREATE VIEW project_productivity_summary AS
-SELECT
- p.id,
- p.name,
- p.path,
- COUNT(DISTINCT s.id) as total_sessions,
- SUM(s.duration_minutes) as total_time_minutes,
- AVG(s.duration_minutes) as avg_session_minutes,
- COUNT(DISTINCT a.file_path) as unique_files_modified,
- SUM(a.lines_added + a.lines_removed) as total_lines_changed,
- AVG(wp.duration_seconds) as avg_think_time_seconds,
- MAX(s.start_time) as last_activity
-FROM projects p
-LEFT JOIN sessions s ON p.id = s.project_id
-LEFT JOIN activities a ON s.id = a.session_id
-LEFT JOIN waiting_periods wp ON s.id = wp.session_id
-GROUP BY p.id, p.name, p.path;
-```
-
-### daily_productivity_metrics
-
-Daily productivity trends across all projects.
-
-```sql
-CREATE VIEW daily_productivity_metrics AS
-SELECT
- DATE(s.start_time) as date,
- COUNT(DISTINCT s.id) as sessions_count,
- SUM(s.duration_minutes) as total_time_minutes,
- COUNT(DISTINCT a.file_path) as files_modified,
- SUM(a.lines_added + a.lines_removed) as lines_changed,
- AVG(wp.duration_seconds) as avg_think_time,
- COUNT(DISTINCT s.project_id) as projects_worked_on
-FROM sessions s
-LEFT JOIN activities a ON s.id = a.session_id AND a.tool_name IN ('Edit', 'Write')
-LEFT JOIN waiting_periods wp ON s.id = wp.session_id
-WHERE s.end_time IS NOT NULL
-GROUP BY DATE(s.start_time)
-ORDER BY date DESC;
-```
-
-## Data Retention
-
-- **Conversation Full Text**: Stored indefinitely for search and analysis
-- **Activity Details**: Kept for all operations to maintain complete audit trail
-- **Analytics Aggregations**: Computed on-demand from source data
-- **Cleanup**: Manual cleanup tools provided, no automatic data expiration
-
-## Performance Considerations
-
-- Database file size grows approximately 1-5MB per day of active development
-- Full-text search indexes require periodic optimization (`PRAGMA optimize`)
-- Analytics queries use covering indexes to avoid table scans
-- Large file content is not stored, only file paths and change metrics
-
-## Migration Strategy
-
-Schema migrations are handled through versioned SQL scripts in `/migrations/`:
-- Each migration has up/down scripts
-- Version tracking in `schema_versions` table
-- Automatic backup before migrations
-- Rollback capability for failed migrations
\ No newline at end of file
diff --git a/docs/development.md b/docs/development.md
deleted file mode 100644
index a3ab1f8..0000000
--- a/docs/development.md
+++ /dev/null
@@ -1,562 +0,0 @@
-# Development Setup Guide
-
-This guide covers setting up a local development environment for the Claude Code Project Tracker.
-
-## Prerequisites
-
-- **Python 3.8+** with pip
-- **Git** for version control
-- **Node.js 16+** (for web dashboard development)
-- **SQLite3** (usually included with Python)
-
-## Quick Setup
-
-```bash
-# Clone the repository
-git clone
-cd claude-tracker
-
-# Create virtual environment
-python -m venv venv
-source venv/bin/activate # On Windows: venv\Scripts\activate
-
-# Install dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-
-# Initialize database
-python -m app.database.init_db
-
-# Run tests
-pytest
-
-# Start development server
-uvicorn main:app --reload --host 0.0.0.0 --port 8000
-```
-
-## Project Structure
-
-```
-claude-tracker/
-βββ main.py # FastAPI application entry point
-βββ requirements.txt # Production dependencies
-βββ requirements-dev.txt # Development dependencies
-βββ pytest.ini # Pytest configuration
-βββ .env.example # Environment variable template
-βββ app/ # Main application code
-β βββ __init__.py
-β βββ models/ # Database models
-β β βββ __init__.py
-β β βββ base.py # Base model class
-β β βββ project.py # Project model
-β β βββ session.py # Session model
-β β βββ ... # Other models
-β βββ api/ # API route handlers
-β β βββ __init__.py
-β β βββ dependencies.py # FastAPI dependencies
-β β βββ sessions.py # Session endpoints
-β β βββ conversations.py # Conversation endpoints
-β β βββ ... # Other endpoints
-β βββ database/ # Database management
-β β βββ __init__.py
-β β βββ connection.py # Database connection
-β β βββ init_db.py # Database initialization
-β β βββ migrations/ # Schema migrations
-β βββ analytics/ # Analytics and insights engine
-β β βββ __init__.py
-β β βββ productivity.py # Productivity metrics
-β β βββ patterns.py # Pattern analysis
-β β βββ reports.py # Report generation
-β βββ dashboard/ # Web dashboard
-β βββ static/ # CSS, JS, images
-β βββ templates/ # HTML templates
-β βββ routes.py # Dashboard routes
-βββ tests/ # Test suite
-β βββ __init__.py
-β βββ conftest.py # Pytest fixtures
-β βββ test_models.py # Model tests
-β βββ test_api.py # API tests
-β βββ test_analytics.py # Analytics tests
-β βββ integration/ # Integration tests
-βββ config/ # Configuration files
-βββ docs/ # Documentation
-βββ data/ # Database files (created at runtime)
-βββ migrations/ # Database migrations
-```
-
-## Dependencies
-
-### Core Dependencies (`requirements.txt`)
-
-```
-fastapi==0.104.1 # Web framework
-uvicorn[standard]==0.24.0 # ASGI server
-sqlalchemy==2.0.23 # ORM
-sqlite3 # Database (built into Python)
-pydantic==2.5.0 # Data validation
-jinja2==3.1.2 # Template engine
-python-multipart==0.0.6 # Form parsing
-python-jose[cryptography]==3.3.0 # JWT tokens
-passlib[bcrypt]==1.7.4 # Password hashing
-```
-
-### Development Dependencies (`requirements-dev.txt`)
-
-```
-pytest==7.4.3 # Testing framework
-pytest-asyncio==0.21.1 # Async testing
-pytest-cov==4.1.0 # Coverage reporting
-httpx==0.25.2 # HTTP client for testing
-faker==20.1.0 # Test data generation
-black==23.11.0 # Code formatting
-isort==5.12.0 # Import sorting
-flake8==6.1.0 # Linting
-mypy==1.7.1 # Type checking
-pre-commit==3.6.0 # Git hooks
-```
-
-## Environment Configuration
-
-Copy the example environment file:
-
-```bash
-cp .env.example .env
-```
-
-Configure these variables in `.env`:
-
-```bash
-# Database
-DATABASE_URL=sqlite:///./data/tracker.db
-
-# API Configuration
-API_HOST=0.0.0.0
-API_PORT=8000
-DEBUG=true
-
-# Security (generate with: openssl rand -hex 32)
-SECRET_KEY=your-secret-key-here
-ACCESS_TOKEN_EXPIRE_MINUTES=30
-
-# Analytics
-ENABLE_ANALYTICS=true
-ANALYTICS_BATCH_SIZE=1000
-
-# Logging
-LOG_LEVEL=INFO
-LOG_FILE=tracker.log
-```
-
-## Database Setup
-
-### Initialize Database
-
-```bash
-# Create database and tables
-python -m app.database.init_db
-
-# Verify database creation
-sqlite3 data/tracker.db ".tables"
-```
-
-### Database Migrations
-
-```bash
-# Create a new migration
-python -m app.database.migrate create "add_new_field"
-
-# Apply migrations
-python -m app.database.migrate up
-
-# Rollback migration
-python -m app.database.migrate down
-```
-
-### Sample Data
-
-Load test data for development:
-
-```bash
-# Load sample projects and sessions
-python -m app.database.seed_data
-
-# Clear all data
-python -m app.database.clear_data
-```
-
-## Testing
-
-### Run Tests
-
-```bash
-# Run all tests
-pytest
-
-# Run with coverage
-pytest --cov=app --cov-report=html
-
-# Run specific test file
-pytest tests/test_api.py
-
-# Run tests matching pattern
-pytest -k "test_session"
-
-# Run tests with verbose output
-pytest -v
-```
-
-### Test Database
-
-Tests use a separate in-memory database:
-
-```python
-# tests/conftest.py
-@pytest.fixture
-async def test_db():
- # Create in-memory SQLite database for testing
- engine = create_async_engine("sqlite+aiosqlite:///:memory:")
- # ... setup code
-```
-
-### Writing Tests
-
-```python
-# tests/test_api.py
-import pytest
-from httpx import AsyncClient
-from app.main import app
-
-@pytest.mark.asyncio
-async def test_create_session(test_db, test_client):
- response = await test_client.post(
- "/api/session/start",
- json={
- "session_type": "startup",
- "working_directory": "/test/path"
- }
- )
- assert response.status_code == 201
- data = response.json()
- assert data["session_id"] is not None
-```
-
-## Development Workflow
-
-### Code Style
-
-We use Black for formatting and isort for import sorting:
-
-```bash
-# Format code
-black app/ tests/
-
-# Sort imports
-isort app/ tests/
-
-# Check formatting without changes
-black --check app/ tests/
-```
-
-### Linting
-
-```bash
-# Run flake8 linting
-flake8 app/ tests/
-
-# Type checking with mypy
-mypy app/
-```
-
-### Pre-commit Hooks
-
-Install pre-commit hooks to run checks automatically:
-
-```bash
-# Install hooks
-pre-commit install
-
-# Run hooks manually
-pre-commit run --all-files
-```
-
-### Git Workflow
-
-1. **Create feature branch:**
- ```bash
- git checkout -b feature/new-analytics-endpoint
- ```
-
-2. **Make changes and test:**
- ```bash
- # Make your changes
- pytest # Run tests
- black app/ tests/ # Format code
- ```
-
-3. **Commit changes:**
- ```bash
- git add .
- git commit -m "Add new analytics endpoint for productivity metrics"
- ```
-
-4. **Push and create PR:**
- ```bash
- git push origin feature/new-analytics-endpoint
- ```
-
-## API Development
-
-### Adding New Endpoints
-
-1. **Define Pydantic schemas** in `app/models/schemas.py`:
- ```python
- class NewFeatureRequest(BaseModel):
- name: str
- description: Optional[str] = None
- ```
-
-2. **Create route handler** in appropriate module:
- ```python
- @router.post("/api/new-feature", response_model=NewFeatureResponse)
- async def create_new_feature(
- request: NewFeatureRequest,
- db: AsyncSession = Depends(get_db)
- ):
- # Implementation
- ```
-
-3. **Add tests** in `tests/test_api.py`:
- ```python
- async def test_create_new_feature(test_client):
- # Test implementation
- ```
-
-### Database Queries
-
-Use SQLAlchemy with async/await:
-
-```python
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from app.models.project import Project
-
-async def get_projects(db: AsyncSession, limit: int = 10):
- result = await db.execute(
- select(Project).limit(limit)
- )
- return result.scalars().all()
-```
-
-## Frontend Development
-
-### Web Dashboard
-
-The dashboard uses vanilla HTML/CSS/JavaScript:
-
-```
-app/dashboard/
-βββ static/
-β βββ css/
-β β βββ dashboard.css
-β βββ js/
-β β βββ dashboard.js
-β β βββ charts.js
-β β βββ api-client.js
-β βββ images/
-βββ templates/
- βββ base.html
- βββ dashboard.html
- βββ projects.html
-```
-
-### Adding New Dashboard Pages
-
-1. **Create HTML template:**
- ```html
-
- {% extends "base.html" %}
- {% block content %}
-
- {% endblock %}
- ```
-
-2. **Add route handler:**
- ```python
- @dashboard_router.get("/new-page")
- async def new_page(request: Request):
- return templates.TemplateResponse("new-page.html", {"request": request})
- ```
-
-3. **Add JavaScript if needed:**
- ```javascript
- // app/dashboard/static/js/new-page.js
- class NewPageController {
- // Page logic
- }
- ```
-
-## Debugging
-
-### Logging
-
-Configure logging in `main.py`:
-
-```python
-import logging
-logging.basicConfig(
- level=logging.INFO,
- format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
- handlers=[
- logging.FileHandler("tracker.log"),
- logging.StreamHandler()
- ]
-)
-```
-
-### Database Debugging
-
-Enable SQL query logging:
-
-```python
-# In development.py
-engine = create_async_engine(
- DATABASE_URL,
- echo=True # This logs all SQL queries
-)
-```
-
-### API Debugging
-
-Use FastAPI's automatic documentation:
-
-- **Swagger UI**: http://localhost:8000/docs
-- **ReDoc**: http://localhost:8000/redoc
-
-### Hook Debugging
-
-Test hooks manually:
-
-```bash
-# Test session start
-curl -X POST http://localhost:8000/api/session/start \
- -H "Content-Type: application/json" \
- -d '{"session_type":"startup","working_directory":"'$(pwd)'"}'
-
-# Check logs
-tail -f tracker.log
-```
-
-## Performance
-
-### Database Optimization
-
-```bash
-# Analyze query performance
-sqlite3 data/tracker.db "EXPLAIN QUERY PLAN SELECT ..."
-
-# Rebuild indexes
-sqlite3 data/tracker.db "REINDEX;"
-
-# Vacuum database
-sqlite3 data/tracker.db "VACUUM;"
-```
-
-### API Performance
-
-```bash
-# Profile API endpoints
-pip install line_profiler
-kernprof -l -v app/api/sessions.py
-```
-
-## Deployment
-
-### Production Setup
-
-1. **Environment variables:**
- ```bash
- DEBUG=false
- API_HOST=127.0.0.1
- ```
-
-2. **Database backup:**
- ```bash
- cp data/tracker.db data/tracker.db.backup
- ```
-
-3. **Run with Gunicorn:**
- ```bash
- pip install gunicorn
- gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker
- ```
-
-### Docker Setup
-
-```dockerfile
-FROM python:3.11-slim
-
-WORKDIR /app
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-
-COPY . .
-EXPOSE 8000
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
-```
-
-## Contributing
-
-1. **Fork the repository**
-2. **Create a feature branch**
-3. **Add tests for new features**
-4. **Ensure all tests pass**
-5. **Follow code style guidelines**
-6. **Submit a pull request**
-
-### Pull Request Checklist
-
-- [ ] Tests added/updated
-- [ ] Documentation updated
-- [ ] Code formatted with Black
-- [ ] Type hints added
-- [ ] No linting errors
-- [ ] Database migrations created if needed
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Import errors:**
- ```bash
- # Ensure you're in the virtual environment
- source venv/bin/activate
-
- # Check Python path
- python -c "import sys; print(sys.path)"
- ```
-
-2. **Database locked:**
- ```bash
- # Check for hanging processes
- ps aux | grep python
-
- # Remove lock files
- rm data/tracker.db-wal data/tracker.db-shm
- ```
-
-3. **Port already in use:**
- ```bash
- # Find process using port 8000
- lsof -i :8000
-
- # Use different port
- uvicorn main:app --port 8001
- ```
-
-### Getting Help
-
-- Check the [API documentation](api-spec.yaml)
-- Review test files for usage examples
-- Open an issue for bugs or feature requests
-- Join development discussions in issues
\ No newline at end of file
diff --git a/docs/hook-setup.md b/docs/hook-setup.md
deleted file mode 100644
index 1a823ae..0000000
--- a/docs/hook-setup.md
+++ /dev/null
@@ -1,279 +0,0 @@
-# Claude Code Hook Setup Guide
-
-This guide explains how to configure Claude Code hooks to automatically track your development sessions with the Project Tracker API.
-
-## Overview
-
-Claude Code hooks are shell commands that execute in response to specific events. We'll configure hooks to send HTTP requests to our tracking API whenever key development events occur.
-
-## Prerequisites
-
-1. **Claude Code Project Tracker** server running on `http://localhost:8000`
-2. **curl** or **httpie** available in your shell
-3. **jq** for JSON processing (recommended)
-
-## Hook Configuration Location
-
-Claude Code hooks are configured in your settings file:
-- **Linux/macOS**: `~/.config/claude-code/settings.json`
-- **Windows**: `%APPDATA%\claude-code\settings.json`
-
-## Complete Hook Configuration
-
-Add this hooks section to your Claude Code settings:
-
-```json
-{
- "hooks": {
- "SessionStart": [
- {
- "matcher": "startup",
- "command": "curl -s -X POST http://localhost:8000/api/session/start -H 'Content-Type: application/json' -d '{\"session_type\":\"startup\",\"working_directory\":\"'\"$PWD\"'\",\"git_branch\":\"'$(git branch --show-current 2>/dev/null || echo \"unknown\")'\",\"git_repo\":\"'$(git config --get remote.origin.url 2>/dev/null || echo \"null\")'\",\"environment\":{\"pwd\":\"'\"$PWD\"'\",\"user\":\"'\"$USER\"'\",\"timestamp\":\"'$(date -Iseconds)'\"}}' > /dev/null 2>&1 &"
- },
- {
- "matcher": "resume",
- "command": "curl -s -X POST http://localhost:8000/api/session/start -H 'Content-Type: application/json' -d '{\"session_type\":\"resume\",\"working_directory\":\"'\"$PWD\"'\",\"git_branch\":\"'$(git branch --show-current 2>/dev/null || echo \"unknown\")'\",\"git_repo\":\"'$(git config --get remote.origin.url 2>/dev/null || echo \"null\")'\",\"environment\":{\"pwd\":\"'\"$PWD\"'\",\"user\":\"'\"$USER\"'\",\"timestamp\":\"'$(date -Iseconds)'\"}}' > /dev/null 2>&1 &"
- },
- {
- "matcher": "clear",
- "command": "curl -s -X POST http://localhost:8000/api/session/start -H 'Content-Type: application/json' -d '{\"session_type\":\"clear\",\"working_directory\":\"'\"$PWD\"'\",\"git_branch\":\"'$(git branch --show-current 2>/dev/null || echo \"unknown\")'\",\"git_repo\":\"'$(git config --get remote.origin.url 2>/dev/null || echo \"null\")'\",\"environment\":{\"pwd\":\"'\"$PWD\"'\",\"user\":\"'\"$USER\"'\",\"timestamp\":\"'$(date -Iseconds)'\"}}' > /dev/null 2>&1 &"
- }
- ],
- "UserPromptSubmit": [
- {
- "command": "echo '{\"session_id\":1,\"timestamp\":\"'$(date -Iseconds)'\",\"user_prompt\":\"'\"$CLAUDE_USER_PROMPT\"'\",\"exchange_type\":\"user_prompt\"}' | curl -s -X POST http://localhost:8000/api/conversation -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- }
- ],
- "Notification": [
- {
- "command": "curl -s -X POST http://localhost:8000/api/waiting/start -H 'Content-Type: application/json' -d '{\"session_id\":1,\"timestamp\":\"'$(date -Iseconds)'\",\"context_before\":\"Claude is waiting for input\"}' > /dev/null 2>&1 &"
- }
- ],
- "PostToolUse": [
- {
- "matcher": "Edit",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Edit\",\"action\":\"file_edit\",\"file_path\":\"'\"$CLAUDE_TOOL_FILE_PATH\"'\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Write",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Write\",\"action\":\"file_write\",\"file_path\":\"'\"$CLAUDE_TOOL_FILE_PATH\"'\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Read",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Read\",\"action\":\"file_read\",\"file_path\":\"'\"$CLAUDE_TOOL_FILE_PATH\"'\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Bash",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Bash\",\"action\":\"command_execution\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"command\":\"'\"$CLAUDE_BASH_COMMAND\"'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Grep",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Grep\",\"action\":\"search\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"pattern\":\"'\"$CLAUDE_GREP_PATTERN\"'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Glob",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Glob\",\"action\":\"file_search\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"pattern\":\"'\"$CLAUDE_GLOB_PATTERN\"'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- },
- {
- "matcher": "Task",
- "command": "echo '{\"session_id\":1,\"tool_name\":\"Task\",\"action\":\"subagent_call\",\"timestamp\":\"'$(date -Iseconds)'\",\"metadata\":{\"task_type\":\"'\"$CLAUDE_TASK_TYPE\"'\",\"success\":true},\"success\":true}' | curl -s -X POST http://localhost:8000/api/activity -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 &"
- }
- ],
- "Stop": [
- {
- "command": "echo '{\"session_id\":1,\"timestamp\":\"'$(date -Iseconds)'\",\"claude_response\":\"Response completed\",\"exchange_type\":\"claude_response\"}' | curl -s -X POST http://localhost:8000/api/conversation -H 'Content-Type: application/json' -d @- > /dev/null 2>&1 && curl -s -X POST http://localhost:8000/api/waiting/end -H 'Content-Type: application/json' -d '{\"session_id\":1,\"timestamp\":\"'$(date -Iseconds)'\"}' > /dev/null 2>&1 &"
- }
- ]
- }
-}
-```
-
-## Simplified Hook Configuration
-
-For easier setup, you can use our provided configuration file:
-
-```bash
-# Copy the hook configuration to Claude Code settings
-cp config/claude-hooks.json ~/.config/claude-code/
-```
-
-## Hook Details
-
-### SessionStart Hooks
-
-Triggered when starting Claude Code or resuming a session:
-- **startup**: Fresh start of Claude Code
-- **resume**: Resuming after --resume flag
-- **clear**: Starting after clearing history
-
-**Data Captured:**
-- Working directory
-- Git branch and repository
-- System environment info
-- Session type
-
-### UserPromptSubmit Hook
-
-Triggered when you submit a prompt to Claude:
-
-**Data Captured:**
-- Your input message
-- Timestamp
-- Session context
-
-### Notification Hook
-
-Triggered when Claude is waiting for input:
-
-**Data Captured:**
-- Wait start time
-- Context before waiting
-
-### PostToolUse Hooks
-
-Triggered after successful tool execution:
-
-**Tools Tracked:**
-- **Edit/Write**: File modifications
-- **Read**: File examinations
-- **Bash**: Command executions
-- **Grep/Glob**: Search operations
-- **Task**: Subagent usage
-
-**Data Captured:**
-- Tool name and action
-- Target files
-- Success/failure status
-- Tool-specific metadata
-
-### Stop Hook
-
-Triggered when Claude finishes responding:
-
-**Data Captured:**
-- Response completion
-- End of waiting period
-- Session activity summary
-
-## Testing Hook Configuration
-
-1. **Start the tracker server:**
- ```bash
- python main.py
- ```
-
-2. **Verify hooks are working:**
- ```bash
- # Check server logs for incoming requests
- tail -f tracker.log
-
- # Test a simple operation in Claude Code
- # You should see API calls in the logs
- ```
-
-3. **Manual hook testing:**
- ```bash
- # Test session start hook
- curl -X POST http://localhost:8000/api/session/start \
- -H 'Content-Type: application/json' \
- -d '{"session_type":"startup","working_directory":"'$(pwd)'"}'
- ```
-
-## Environment Variables
-
-The hooks can use these Claude Code environment variables:
-
-- `$CLAUDE_USER_PROMPT` - User's input message
-- `$CLAUDE_TOOL_FILE_PATH` - File path for file operations
-- `$CLAUDE_BASH_COMMAND` - Bash command being executed
-- `$CLAUDE_GREP_PATTERN` - Search pattern for Grep
-- `$CLAUDE_GLOB_PATTERN` - File pattern for Glob
-- `$CLAUDE_TASK_TYPE` - Type of Task/subagent
-
-## Troubleshooting
-
-### Hooks Not Firing
-
-1. **Check Claude Code settings syntax:**
- ```bash
- # Validate JSON syntax
- python -m json.tool ~/.config/claude-code/settings.json
- ```
-
-2. **Verify tracker server is running:**
- ```bash
- curl http://localhost:8000/api/projects
- ```
-
-3. **Check hook command syntax:**
- ```bash
- # Test commands manually in shell
- echo "Testing hook command..."
- ```
-
-### Missing Data
-
-1. **Session ID issues**: The static `session_id: 1` in examples needs dynamic generation
-2. **JSON escaping**: Special characters in prompts/paths may break JSON
-3. **Network issues**: Hooks may fail if server is unreachable
-
-### Performance Impact
-
-- Hooks run asynchronously (`&` at end of commands)
-- Failed hook calls don't interrupt Claude Code operation
-- Network timeouts are handled gracefully
-
-## Advanced Configuration
-
-### Dynamic Session IDs
-
-For production use, implement session ID management:
-
-```bash
-# Store session ID in temp file
-CLAUDE_SESSION_FILE="/tmp/claude-session-id"
-
-# In SessionStart hook:
-SESSION_ID=$(curl -s ... | jq -r '.session_id')
-echo $SESSION_ID > $CLAUDE_SESSION_FILE
-
-# In other hooks:
-SESSION_ID=$(cat $CLAUDE_SESSION_FILE 2>/dev/null || echo "1")
-```
-
-### Conditional Hook Execution
-
-Skip tracking for certain directories:
-
-```bash
-# Only track in specific directories
-if [[ "$PWD" =~ "/projects/" ]]; then
- curl -X POST ...
-fi
-```
-
-### Error Handling
-
-Add error logging to hooks:
-
-```bash
-curl ... 2>> ~/claude-tracker-errors.log || echo "Hook failed: $(date)" >> ~/claude-tracker-errors.log
-```
-
-## Security Considerations
-
-- Hooks execute with your shell privileges
-- API calls are made to localhost only
-- No sensitive data is transmitted externally
-- Hook commands are logged in shell history
-
-## Next Steps
-
-After setting up hooks:
-
-1. Start using Claude Code normally
-2. Check the web dashboard at http://localhost:8000
-3. Review captured data and analytics
-4. Adjust hook configuration as needed
-
-For detailed API documentation, see [API Specification](api-spec.yaml).
\ No newline at end of file
diff --git a/main.py b/main.py
deleted file mode 100644
index fc7ffca..0000000
--- a/main.py
+++ /dev/null
@@ -1,81 +0,0 @@
-"""
-Claude Code Project Tracker - FastAPI Application
-"""
-
-from contextlib import asynccontextmanager
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import RedirectResponse
-
-from app.database.connection import init_database, close_database
-from app.api import sessions, conversations, activities, waiting, git, projects, analytics
-from app.dashboard.routes import dashboard_router
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
- """Application lifespan management."""
- # Startup
- print("Starting Claude Code Project Tracker...")
- await init_database()
- yield
- # Shutdown
- print("Shutting down...")
- await close_database()
-
-
-# Create FastAPI app
-app = FastAPI(
- title="Claude Code Project Tracker",
- description="API for tracking Claude Code development sessions and productivity",
- version="1.0.0",
- lifespan=lifespan
-)
-
-# Add CORS middleware
-app.add_middleware(
- CORSMiddleware,
- allow_origins=["*"], # In production, replace with specific origins
- allow_credentials=True,
- allow_methods=["*"],
- allow_headers=["*"],
-)
-
-# Include API routers
-app.include_router(sessions.router, prefix="/api", tags=["Sessions"])
-app.include_router(conversations.router, prefix="/api", tags=["Conversations"])
-app.include_router(activities.router, prefix="/api", tags=["Activities"])
-app.include_router(waiting.router, prefix="/api", tags=["Waiting Periods"])
-app.include_router(git.router, prefix="/api", tags=["Git Operations"])
-app.include_router(projects.router, prefix="/api", tags=["Projects"])
-app.include_router(analytics.router, prefix="/api", tags=["Analytics"])
-
-# Include dashboard routes
-app.include_router(dashboard_router, tags=["Dashboard"])
-
-# Mount static files
-app.mount("/static", StaticFiles(directory="app/dashboard/static"), name="static")
-
-# Root redirect to dashboard
-@app.get("/")
-async def root():
- """Redirect root to dashboard."""
- return RedirectResponse(url="/dashboard")
-
-
-@app.get("/health")
-async def health_check():
- """Health check endpoint."""
- return {"status": "healthy", "service": "claude-code-tracker"}
-
-
-if __name__ == "__main__":
- import uvicorn
- uvicorn.run(
- "main:app",
- host="0.0.0.0",
- port=8000,
- reload=True,
- log_level="info"
- )
\ No newline at end of file
diff --git a/pytest.ini b/pytest.ini
deleted file mode 100644
index 2c25e7b..0000000
--- a/pytest.ini
+++ /dev/null
@@ -1,15 +0,0 @@
-[tool:pytest]
-minversion = 6.0
-addopts = -ra -q --strict-markers --strict-config
-testpaths = tests
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-asyncio_mode = auto
-markers =
- unit: Unit tests that don't require external dependencies
- integration: Integration tests that require database/API
- slow: Tests that take longer than 1 second to run
- api: API endpoint tests
- analytics: Analytics and insights tests
- hooks: Hook simulation tests
\ No newline at end of file
diff --git a/requirements-dev.txt b/requirements-dev.txt
deleted file mode 100644
index c46f3f5..0000000
--- a/requirements-dev.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-pytest==7.4.3
-pytest-asyncio==0.21.1
-pytest-cov==4.1.0
-httpx==0.25.2
-faker==20.1.0
-black==23.11.0
-isort==5.12.0
-flake8==6.1.0
-mypy==1.7.1
-pre-commit==3.6.0
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 155846b..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-sqlalchemy==2.0.23
-aiosqlite==0.19.0
-pydantic==2.5.0
-jinja2==3.1.2
-python-multipart==0.0.6
-python-jose[cryptography]==3.3.0
-passlib[bcrypt]==1.7.4
-python-dateutil==2.8.2
-typing-extensions==4.8.0
\ No newline at end of file
diff --git a/tests/conftest.py b/tests/conftest.py
deleted file mode 100644
index e63efc9..0000000
--- a/tests/conftest.py
+++ /dev/null
@@ -1,256 +0,0 @@
-import pytest
-import asyncio
-from typing import AsyncGenerator
-from httpx import AsyncClient
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
-from sqlalchemy.pool import StaticPool
-
-from app.main import app
-from app.database.connection import get_db
-from app.models.base import Base
-from app.models.project import Project
-from app.models.session import Session
-from app.models.conversation import Conversation
-from app.models.activity import Activity
-from app.models.waiting_period import WaitingPeriod
-from app.models.git_operation import GitOperation
-
-TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
-
-@pytest.fixture(scope="session")
-def event_loop():
- """Create an instance of the default event loop for the test session."""
- loop = asyncio.get_event_loop_policy().new_event_loop()
- yield loop
- loop.close()
-
-@pytest.fixture
-async def test_engine():
- """Create test database engine."""
- engine = create_async_engine(
- TEST_DATABASE_URL,
- connect_args={
- "check_same_thread": False,
- },
- poolclass=StaticPool,
- echo=False, # Set to True for SQL debugging
- )
- yield engine
- await engine.dispose()
-
-@pytest.fixture
-async def test_db(test_engine) -> AsyncGenerator[AsyncSession, None]:
- """Create test database session."""
- # Create all tables
- async with test_engine.begin() as conn:
- await conn.run_sync(Base.metadata.create_all)
-
- # Create session factory
- async_session = async_sessionmaker(
- test_engine, class_=AsyncSession, expire_on_commit=False
- )
-
- async with async_session() as session:
- yield session
- await session.rollback()
-
-@pytest.fixture
-async def test_client(test_db: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
- """Create test HTTP client."""
- def override_get_db():
- return test_db
-
- app.dependency_overrides[get_db] = override_get_db
-
- async with AsyncClient(app=app, base_url="http://test") as client:
- yield client
-
- # Clean up
- app.dependency_overrides.clear()
-
-@pytest.fixture
-async def sample_project(test_db: AsyncSession) -> Project:
- """Create a sample project for testing."""
- project = Project(
- name="Test Project",
- path="/home/user/test-project",
- git_repo="https://github.com/user/test-project",
- languages=["python", "javascript"]
- )
- test_db.add(project)
- await test_db.commit()
- await test_db.refresh(project)
- return project
-
-@pytest.fixture
-async def sample_session(test_db: AsyncSession, sample_project: Project) -> Session:
- """Create a sample session for testing."""
- session = Session(
- project_id=sample_project.id,
- session_type="startup",
- working_directory="/home/user/test-project",
- git_branch="main",
- environment={"user": "testuser", "pwd": "/home/user/test-project"}
- )
- test_db.add(session)
- await test_db.commit()
- await test_db.refresh(session)
- return session
-
-@pytest.fixture
-async def sample_conversation(test_db: AsyncSession, sample_session: Session) -> Conversation:
- """Create a sample conversation for testing."""
- conversation = Conversation(
- session_id=sample_session.id,
- user_prompt="How do I implement a feature?",
- claude_response="You can implement it by following these steps...",
- tools_used=["Edit", "Write"],
- files_affected=["main.py", "utils.py"],
- exchange_type="user_prompt"
- )
- test_db.add(conversation)
- await test_db.commit()
- await test_db.refresh(conversation)
- return conversation
-
-@pytest.fixture
-async def sample_activity(test_db: AsyncSession, sample_session: Session) -> Activity:
- """Create a sample activity for testing."""
- activity = Activity(
- session_id=sample_session.id,
- tool_name="Edit",
- action="file_edit",
- file_path="/home/user/test-project/main.py",
- metadata={"lines_changed": 10},
- success=True,
- lines_added=5,
- lines_removed=2
- )
- test_db.add(activity)
- await test_db.commit()
- await test_db.refresh(activity)
- return activity
-
-@pytest.fixture
-async def sample_waiting_period(test_db: AsyncSession, sample_session: Session) -> WaitingPeriod:
- """Create a sample waiting period for testing."""
- waiting_period = WaitingPeriod(
- session_id=sample_session.id,
- duration_seconds=30,
- context_before="Claude finished responding",
- context_after="User asked a follow-up question",
- likely_activity="thinking"
- )
- test_db.add(waiting_period)
- await test_db.commit()
- await test_db.refresh(waiting_period)
- return waiting_period
-
-@pytest.fixture
-async def sample_git_operation(test_db: AsyncSession, sample_session: Session) -> GitOperation:
- """Create a sample git operation for testing."""
- git_operation = GitOperation(
- session_id=sample_session.id,
- operation="commit",
- command="git commit -m 'Add new feature'",
- result="[main 123abc] Add new feature",
- success=True,
- files_changed=["main.py", "utils.py"],
- lines_added=15,
- lines_removed=3,
- commit_hash="123abc456def"
- )
- test_db.add(git_operation)
- await test_db.commit()
- await test_db.refresh(git_operation)
- return git_operation
-
-# Faker fixtures for generating test data
-@pytest.fixture
-def fake():
- """Faker instance for generating test data."""
- from faker import Faker
- return Faker()
-
-@pytest.fixture
-def project_factory(fake):
- """Factory for creating project test data."""
- def _create_project_data(**overrides):
- data = {
- "name": fake.company(),
- "path": fake.file_path(depth=3),
- "git_repo": fake.url(),
- "languages": fake.random_elements(
- elements=["python", "javascript", "typescript", "go", "rust"],
- length=fake.random_int(min=1, max=3),
- unique=True
- )
- }
- data.update(overrides)
- return data
- return _create_project_data
-
-@pytest.fixture
-def session_factory(fake):
- """Factory for creating session test data."""
- def _create_session_data(**overrides):
- data = {
- "session_type": fake.random_element(elements=["startup", "resume", "clear"]),
- "working_directory": fake.file_path(depth=3),
- "git_branch": fake.word(),
- "environment": {
- "user": fake.user_name(),
- "pwd": fake.file_path(depth=3),
- "timestamp": fake.iso8601()
- }
- }
- data.update(overrides)
- return data
- return _create_session_data
-
-@pytest.fixture
-def conversation_factory(fake):
- """Factory for creating conversation test data."""
- def _create_conversation_data(**overrides):
- data = {
- "user_prompt": fake.sentence(nb_words=10),
- "claude_response": fake.paragraph(nb_sentences=3),
- "tools_used": fake.random_elements(
- elements=["Edit", "Write", "Read", "Bash", "Grep"],
- length=fake.random_int(min=1, max=3),
- unique=True
- ),
- "files_affected": [fake.file_path() for _ in range(fake.random_int(min=0, max=3))],
- "exchange_type": fake.random_element(elements=["user_prompt", "claude_response"])
- }
- data.update(overrides)
- return data
- return _create_conversation_data
-
-# Utility functions for tests
-@pytest.fixture
-def assert_response():
- """Helper for asserting API response structure."""
- def _assert_response(response, status_code=200, required_keys=None):
- assert response.status_code == status_code
- if required_keys:
- data = response.json()
- for key in required_keys:
- assert key in data
- return response.json()
- return _assert_response
-
-@pytest.fixture
-def create_test_data():
- """Helper for creating test data in database."""
- async def _create_test_data(db: AsyncSession, model_class, count=1, **kwargs):
- items = []
- for i in range(count):
- item = model_class(**kwargs)
- db.add(item)
- items.append(item)
- await db.commit()
- for item in items:
- await db.refresh(item)
- return items[0] if count == 1 else items
- return _create_test_data
\ No newline at end of file
diff --git a/tests/fixtures.py b/tests/fixtures.py
deleted file mode 100644
index 4015c93..0000000
--- a/tests/fixtures.py
+++ /dev/null
@@ -1,413 +0,0 @@
-"""
-Test fixtures and sample data for the Claude Code Project Tracker.
-"""
-
-from datetime import datetime, timedelta
-from typing import Dict, List, Any
-from faker import Faker
-
-fake = Faker()
-
-class TestDataFactory:
- """Factory for creating realistic test data."""
-
- @staticmethod
- def create_project_data(**overrides) -> Dict[str, Any]:
- """Create sample project data."""
- data = {
- "name": fake.company(),
- "path": fake.file_path(depth=3, extension=""),
- "git_repo": fake.url().replace("http://", "https://github.com/"),
- "languages": fake.random_elements(
- elements=["python", "javascript", "typescript", "go", "rust", "java", "cpp"],
- length=fake.random_int(min=1, max=4),
- unique=True
- ),
- "created_at": fake.date_time_between(start_date="-1y", end_date="now"),
- "last_session": fake.date_time_between(start_date="-30d", end_date="now"),
- "total_sessions": fake.random_int(min=1, max=50),
- "total_time_minutes": fake.random_int(min=30, max=2000),
- "files_modified_count": fake.random_int(min=5, max=100),
- "lines_changed_count": fake.random_int(min=100, max=5000)
- }
- data.update(overrides)
- return data
-
- @staticmethod
- def create_session_data(project_id: int = 1, **overrides) -> Dict[str, Any]:
- """Create sample session data."""
- start_time = fake.date_time_between(start_date="-7d", end_date="now")
- duration = fake.random_int(min=5, max=180) # 5 minutes to 3 hours
-
- data = {
- "project_id": project_id,
- "start_time": start_time,
- "end_time": start_time + timedelta(minutes=duration),
- "session_type": fake.random_element(elements=["startup", "resume", "clear"]),
- "working_directory": fake.file_path(depth=3, extension=""),
- "git_branch": fake.random_element(elements=["main", "develop", "feature/new-feature", "bugfix/issue-123"]),
- "environment": {
- "user": fake.user_name(),
- "pwd": fake.file_path(depth=3, extension=""),
- "python_version": "3.11.0",
- "node_version": "18.17.0"
- },
- "duration_minutes": duration,
- "activity_count": fake.random_int(min=3, max=50),
- "conversation_count": fake.random_int(min=2, max=30),
- "files_touched": [fake.file_path() for _ in range(fake.random_int(min=1, max=8))]
- }
- data.update(overrides)
- return data
-
- @staticmethod
- def create_conversation_data(session_id: int = 1, **overrides) -> Dict[str, Any]:
- """Create sample conversation data."""
- prompts = [
- "How do I implement user authentication?",
- "Can you help me debug this error?",
- "What's the best way to structure this code?",
- "Help me optimize this function for performance",
- "How do I add tests for this component?",
- "Can you review this code for best practices?",
- "What libraries should I use for this feature?",
- "How do I handle errors in this async function?"
- ]
-
- responses = [
- "I can help you implement user authentication. Here's a comprehensive approach...",
- "Let me analyze this error and provide a solution...",
- "For code structure, I recommend following these patterns...",
- "Here are several optimization strategies for your function...",
- "Let's add comprehensive tests for this component...",
- "I've reviewed your code and here are my recommendations...",
- "For this feature, I suggest these well-maintained libraries...",
- "Here's how to properly handle errors in async functions..."
- ]
-
- data = {
- "session_id": session_id,
- "timestamp": fake.date_time_between(start_date="-7d", end_date="now"),
- "user_prompt": fake.random_element(elements=prompts),
- "claude_response": fake.random_element(elements=responses),
- "tools_used": fake.random_elements(
- elements=["Edit", "Write", "Read", "Bash", "Grep", "Glob", "Task"],
- length=fake.random_int(min=1, max=4),
- unique=True
- ),
- "files_affected": [
- fake.file_path(extension=ext)
- for ext in fake.random_elements(
- elements=["py", "js", "ts", "go", "rs", "java", "cpp", "md"],
- length=fake.random_int(min=0, max=3),
- unique=True
- )
- ],
- "context": {
- "intent": fake.random_element(elements=["debugging", "implementation", "learning", "optimization"]),
- "complexity": fake.random_element(elements=["low", "medium", "high"])
- },
- "tokens_input": fake.random_int(min=50, max=500),
- "tokens_output": fake.random_int(min=100, max=1000),
- "exchange_type": fake.random_element(elements=["user_prompt", "claude_response"])
- }
- data.update(overrides)
- return data
-
- @staticmethod
- def create_activity_data(session_id: int = 1, **overrides) -> Dict[str, Any]:
- """Create sample activity data."""
- tools = {
- "Edit": {
- "action": "file_edit",
- "metadata": {"lines_changed": fake.random_int(min=1, max=50)},
- "lines_added": fake.random_int(min=0, max=30),
- "lines_removed": fake.random_int(min=0, max=20)
- },
- "Write": {
- "action": "file_write",
- "metadata": {"new_file": fake.boolean()},
- "lines_added": fake.random_int(min=10, max=100),
- "lines_removed": 0
- },
- "Read": {
- "action": "file_read",
- "metadata": {"file_size": fake.random_int(min=100, max=5000)},
- "lines_added": 0,
- "lines_removed": 0
- },
- "Bash": {
- "action": "command_execution",
- "metadata": {
- "command": fake.random_element(elements=[
- "npm install",
- "pytest",
- "git status",
- "python main.py",
- "docker build ."
- ]),
- "exit_code": 0
- },
- "lines_added": 0,
- "lines_removed": 0
- },
- "Grep": {
- "action": "search",
- "metadata": {
- "pattern": fake.word(),
- "matches_found": fake.random_int(min=0, max=20)
- },
- "lines_added": 0,
- "lines_removed": 0
- }
- }
-
- tool_name = fake.random_element(elements=list(tools.keys()))
- tool_config = tools[tool_name]
-
- data = {
- "session_id": session_id,
- "timestamp": fake.date_time_between(start_date="-7d", end_date="now"),
- "tool_name": tool_name,
- "action": tool_config["action"],
- "file_path": fake.file_path() if tool_name in ["Edit", "Write", "Read"] else None,
- "metadata": tool_config["metadata"],
- "success": fake.boolean(chance_of_getting_true=90),
- "error_message": None if fake.boolean(chance_of_getting_true=90) else "Operation failed",
- "lines_added": tool_config.get("lines_added", 0),
- "lines_removed": tool_config.get("lines_removed", 0)
- }
- data.update(overrides)
- return data
-
- @staticmethod
- def create_waiting_period_data(session_id: int = 1, **overrides) -> Dict[str, Any]:
- """Create sample waiting period data."""
- start_time = fake.date_time_between(start_date="-7d", end_date="now")
- duration = fake.random_int(min=5, max=300) # 5 seconds to 5 minutes
-
- activities = {
- "thinking": "User is contemplating the response",
- "research": "User is looking up documentation",
- "external_work": "User is working in another application",
- "break": "User stepped away from the computer"
- }
-
- likely_activity = fake.random_element(elements=list(activities.keys()))
-
- data = {
- "session_id": session_id,
- "start_time": start_time,
- "end_time": start_time + timedelta(seconds=duration),
- "duration_seconds": duration,
- "context_before": "Claude finished providing a detailed explanation",
- "context_after": fake.random_element(elements=[
- "User asked a follow-up question",
- "User requested clarification",
- "User provided additional context",
- "User asked about a different topic"
- ]),
- "likely_activity": likely_activity
- }
- data.update(overrides)
- return data
-
- @staticmethod
- def create_git_operation_data(session_id: int = 1, **overrides) -> Dict[str, Any]:
- """Create sample git operation data."""
- operations = {
- "commit": {
- "command": "git commit -m 'Add new feature'",
- "result": "[main abc123] Add new feature\\n 2 files changed, 15 insertions(+), 3 deletions(-)",
- "files_changed": ["main.py", "utils.py"],
- "lines_added": 15,
- "lines_removed": 3,
- "commit_hash": fake.sha1()[:8]
- },
- "push": {
- "command": "git push origin main",
- "result": "To https://github.com/user/repo.git\\n abc123..def456 main -> main",
- "files_changed": [],
- "lines_added": 0,
- "lines_removed": 0,
- "commit_hash": None
- },
- "pull": {
- "command": "git pull origin main",
- "result": "Already up to date.",
- "files_changed": [],
- "lines_added": 0,
- "lines_removed": 0,
- "commit_hash": None
- },
- "branch": {
- "command": "git checkout -b feature/new-feature",
- "result": "Switched to a new branch 'feature/new-feature'",
- "files_changed": [],
- "lines_added": 0,
- "lines_removed": 0,
- "commit_hash": None
- }
- }
-
- operation = fake.random_element(elements=list(operations.keys()))
- op_config = operations[operation]
-
- data = {
- "session_id": session_id,
- "timestamp": fake.date_time_between(start_date="-7d", end_date="now"),
- "operation": operation,
- "command": op_config["command"],
- "result": op_config["result"],
- "success": fake.boolean(chance_of_getting_true=95),
- "files_changed": op_config["files_changed"],
- "lines_added": op_config["lines_added"],
- "lines_removed": op_config["lines_removed"],
- "commit_hash": op_config["commit_hash"],
- "branch_from": fake.random_element(elements=["main", "develop", "feature/old-feature"]) if operation == "merge" else None,
- "branch_to": fake.random_element(elements=["main", "develop"]) if operation == "merge" else None
- }
- data.update(overrides)
- return data
-
-class SampleDataSets:
- """Pre-defined sample data sets for different test scenarios."""
-
- @staticmethod
- def productive_session() -> Dict[str, List[Dict[str, Any]]]:
- """Data for a highly productive development session."""
- project_data = TestDataFactory.create_project_data(
- name="E-commerce Platform",
- languages=["python", "javascript", "typescript"],
- total_sessions=25,
- total_time_minutes=800
- )
-
- session_data = TestDataFactory.create_session_data(
- session_type="startup",
- duration_minutes=120,
- activity_count=45,
- conversation_count=12
- )
-
- conversations = [
- TestDataFactory.create_conversation_data(
- user_prompt="How do I implement user authentication with JWT?",
- tools_used=["Edit", "Write"],
- files_affected=["auth.py", "models.py"]
- ),
- TestDataFactory.create_conversation_data(
- user_prompt="Can you help me optimize this database query?",
- tools_used=["Edit", "Read"],
- files_affected=["queries.py"]
- ),
- TestDataFactory.create_conversation_data(
- user_prompt="What's the best way to handle async errors?",
- tools_used=["Edit"],
- files_affected=["error_handler.py"]
- )
- ]
-
- activities = [
- TestDataFactory.create_activity_data(tool_name="Edit", lines_added=25, lines_removed=5),
- TestDataFactory.create_activity_data(tool_name="Write", lines_added=50, lines_removed=0),
- TestDataFactory.create_activity_data(tool_name="Bash", metadata={"command": "pytest"}),
- TestDataFactory.create_activity_data(tool_name="Read", file_path="/docs/api.md")
- ]
-
- return {
- "project": project_data,
- "session": session_data,
- "conversations": conversations,
- "activities": activities
- }
-
- @staticmethod
- def debugging_session() -> Dict[str, List[Dict[str, Any]]]:
- """Data for a debugging-focused session with lots of investigation."""
- project_data = TestDataFactory.create_project_data(
- name="Bug Tracking System",
- languages=["go", "typescript"]
- )
-
- session_data = TestDataFactory.create_session_data(
- session_type="resume",
- duration_minutes=90,
- activity_count=35,
- conversation_count=8
- )
-
- conversations = [
- TestDataFactory.create_conversation_data(
- user_prompt="I'm getting a panic in my Go application, can you help debug?",
- tools_used=["Read", "Grep"],
- files_affected=["main.go", "handler.go"],
- context={"intent": "debugging", "complexity": "high"}
- ),
- TestDataFactory.create_conversation_data(
- user_prompt="The tests are failing intermittently, what could be wrong?",
- tools_used=["Read", "Bash"],
- files_affected=["test_handler.go"]
- )
- ]
-
- # Lots of read operations for debugging
- activities = [
- TestDataFactory.create_activity_data(tool_name="Read") for _ in range(8)
- ] + [
- TestDataFactory.create_activity_data(tool_name="Grep", metadata={"pattern": "error", "matches_found": 12}),
- TestDataFactory.create_activity_data(tool_name="Bash", metadata={"command": "go test -v"}),
- TestDataFactory.create_activity_data(tool_name="Edit", lines_added=3, lines_removed=1)
- ]
-
- # Longer thinking periods during debugging
- waiting_periods = [
- TestDataFactory.create_waiting_period_data(
- duration_seconds=180,
- likely_activity="research",
- context_after="User asked about error patterns"
- ),
- TestDataFactory.create_waiting_period_data(
- duration_seconds=120,
- likely_activity="thinking",
- context_after="User provided stack trace"
- )
- ]
-
- return {
- "project": project_data,
- "session": session_data,
- "conversations": conversations,
- "activities": activities,
- "waiting_periods": waiting_periods
- }
-
- @staticmethod
- def learning_session() -> Dict[str, List[Dict[str, Any]]]:
- """Data for a learning-focused session with lots of questions."""
- project_data = TestDataFactory.create_project_data(
- name="Learning Rust",
- languages=["rust"],
- total_sessions=5,
- total_time_minutes=200
- )
-
- conversations = [
- TestDataFactory.create_conversation_data(
- user_prompt="What's the difference between String and &str in Rust?",
- context={"intent": "learning", "complexity": "medium"}
- ),
- TestDataFactory.create_conversation_data(
- user_prompt="How do I handle ownership and borrowing correctly?",
- context={"intent": "learning", "complexity": "high"}
- ),
- TestDataFactory.create_conversation_data(
- user_prompt="Can you explain Rust's trait system?",
- context={"intent": "learning", "complexity": "high"}
- )
- ]
-
- return {
- "project": project_data,
- "conversations": conversations
- }
\ No newline at end of file
diff --git a/tests/test_api.py b/tests/test_api.py
deleted file mode 100644
index 6eccf1a..0000000
--- a/tests/test_api.py
+++ /dev/null
@@ -1,525 +0,0 @@
-"""
-Tests for the Claude Code Project Tracker API endpoints.
-"""
-
-import pytest
-from httpx import AsyncClient
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.project import Project
-from app.models.session import Session
-from tests.fixtures import TestDataFactory
-
-
-class TestSessionAPI:
- """Test session management endpoints."""
-
- @pytest.mark.api
- async def test_start_session_startup(self, test_client: AsyncClient):
- """Test starting a new session with startup type."""
- session_data = TestDataFactory.create_session_data(
- session_type="startup",
- working_directory="/home/user/test-project",
- git_branch="main"
- )
-
- response = await test_client.post("/api/session/start", json=session_data)
-
- assert response.status_code == 201
- data = response.json()
- assert "session_id" in data
- assert "project_id" in data
- assert data["status"] == "started"
-
- @pytest.mark.api
- async def test_start_session_creates_project(self, test_client: AsyncClient):
- """Test that starting a session creates a project if it doesn't exist."""
- session_data = {
- "session_type": "startup",
- "working_directory": "/home/user/new-project",
- "git_repo": "https://github.com/user/new-project",
- "environment": {"user": "testuser"}
- }
-
- response = await test_client.post("/api/session/start", json=session_data)
-
- assert response.status_code == 201
- data = response.json()
- assert data["project_id"] is not None
-
- @pytest.mark.api
- async def test_start_session_resume(self, test_client: AsyncClient):
- """Test resuming an existing session."""
- session_data = TestDataFactory.create_session_data(session_type="resume")
-
- response = await test_client.post("/api/session/start", json=session_data)
-
- assert response.status_code == 201
- data = response.json()
- assert "session_id" in data
-
- @pytest.mark.api
- async def test_end_session(self, test_client: AsyncClient, sample_session: Session):
- """Test ending an active session."""
- end_data = {
- "session_id": sample_session.id,
- "end_reason": "normal"
- }
-
- response = await test_client.post("/api/session/end", json=end_data)
-
- assert response.status_code == 200
- data = response.json()
- assert data["session_id"] == sample_session.id
- assert data["status"] == "ended"
-
- @pytest.mark.api
- async def test_end_nonexistent_session(self, test_client: AsyncClient):
- """Test ending a session that doesn't exist."""
- end_data = {
- "session_id": 99999,
- "end_reason": "normal"
- }
-
- response = await test_client.post("/api/session/end", json=end_data)
-
- assert response.status_code == 404
-
-
-class TestConversationAPI:
- """Test conversation tracking endpoints."""
-
- @pytest.mark.api
- async def test_log_conversation(self, test_client: AsyncClient, sample_session: Session):
- """Test logging a conversation exchange."""
- conversation_data = TestDataFactory.create_conversation_data(
- session_id=sample_session.id,
- user_prompt="How do I implement authentication?",
- claude_response="You can implement authentication using...",
- tools_used=["Edit", "Write"]
- )
-
- response = await test_client.post("/api/conversation", json=conversation_data)
-
- assert response.status_code == 201
-
- @pytest.mark.api
- async def test_log_conversation_user_prompt_only(self, test_client: AsyncClient, sample_session: Session):
- """Test logging just a user prompt."""
- conversation_data = {
- "session_id": sample_session.id,
- "timestamp": "2024-01-01T12:00:00Z",
- "user_prompt": "How do I fix this error?",
- "exchange_type": "user_prompt"
- }
-
- response = await test_client.post("/api/conversation", json=conversation_data)
-
- assert response.status_code == 201
-
- @pytest.mark.api
- async def test_log_conversation_invalid_session(self, test_client: AsyncClient):
- """Test logging conversation with invalid session ID."""
- conversation_data = TestDataFactory.create_conversation_data(session_id=99999)
-
- response = await test_client.post("/api/conversation", json=conversation_data)
-
- assert response.status_code == 404
-
-
-class TestActivityAPI:
- """Test activity tracking endpoints."""
-
- @pytest.mark.api
- async def test_record_activity_edit(self, test_client: AsyncClient, sample_session: Session):
- """Test recording an Edit tool activity."""
- activity_data = TestDataFactory.create_activity_data(
- session_id=sample_session.id,
- tool_name="Edit",
- action="file_edit",
- file_path="/home/user/test.py",
- lines_added=10,
- lines_removed=3
- )
-
- response = await test_client.post("/api/activity", json=activity_data)
-
- assert response.status_code == 201
-
- @pytest.mark.api
- async def test_record_activity_bash(self, test_client: AsyncClient, sample_session: Session):
- """Test recording a Bash command activity."""
- activity_data = TestDataFactory.create_activity_data(
- session_id=sample_session.id,
- tool_name="Bash",
- action="command_execution",
- metadata={"command": "pytest", "exit_code": 0}
- )
-
- response = await test_client.post("/api/activity", json=activity_data)
-
- assert response.status_code == 201
-
- @pytest.mark.api
- async def test_record_activity_failed(self, test_client: AsyncClient, sample_session: Session):
- """Test recording a failed activity."""
- activity_data = TestDataFactory.create_activity_data(
- session_id=sample_session.id,
- success=False,
- error_message="Permission denied"
- )
-
- response = await test_client.post("/api/activity", json=activity_data)
-
- assert response.status_code == 201
-
-
-class TestWaitingAPI:
- """Test waiting period tracking endpoints."""
-
- @pytest.mark.api
- async def test_start_waiting_period(self, test_client: AsyncClient, sample_session: Session):
- """Test starting a waiting period."""
- waiting_data = {
- "session_id": sample_session.id,
- "timestamp": "2024-01-01T12:00:00Z",
- "context_before": "Claude finished responding"
- }
-
- response = await test_client.post("/api/waiting/start", json=waiting_data)
-
- assert response.status_code == 201
-
- @pytest.mark.api
- async def test_end_waiting_period(self, test_client: AsyncClient, sample_session: Session):
- """Test ending a waiting period."""
- # First start a waiting period
- start_data = {
- "session_id": sample_session.id,
- "timestamp": "2024-01-01T12:00:00Z",
- "context_before": "Claude finished responding"
- }
- await test_client.post("/api/waiting/start", json=start_data)
-
- # Then end it
- end_data = {
- "session_id": sample_session.id,
- "timestamp": "2024-01-01T12:05:00Z",
- "duration_seconds": 300,
- "context_after": "User asked follow-up question"
- }
-
- response = await test_client.post("/api/waiting/end", json=end_data)
-
- assert response.status_code == 200
-
-
-class TestGitAPI:
- """Test git operation tracking endpoints."""
-
- @pytest.mark.api
- async def test_record_git_commit(self, test_client: AsyncClient, sample_session: Session):
- """Test recording a git commit operation."""
- git_data = TestDataFactory.create_git_operation_data(
- session_id=sample_session.id,
- operation="commit",
- command="git commit -m 'Add feature'",
- files_changed=["main.py", "utils.py"],
- lines_added=20,
- lines_removed=5
- )
-
- response = await test_client.post("/api/git", json=git_data)
-
- assert response.status_code == 201
-
- @pytest.mark.api
- async def test_record_git_push(self, test_client: AsyncClient, sample_session: Session):
- """Test recording a git push operation."""
- git_data = TestDataFactory.create_git_operation_data(
- session_id=sample_session.id,
- operation="push",
- command="git push origin main"
- )
-
- response = await test_client.post("/api/git", json=git_data)
-
- assert response.status_code == 201
-
-
-class TestProjectAPI:
- """Test project data retrieval endpoints."""
-
- @pytest.mark.api
- async def test_list_projects(self, test_client: AsyncClient, sample_project: Project):
- """Test listing all projects."""
- response = await test_client.get("/api/projects")
-
- assert response.status_code == 200
- data = response.json()
- assert isinstance(data, list)
- assert len(data) >= 1
-
- project = data[0]
- assert "id" in project
- assert "name" in project
- assert "path" in project
-
- @pytest.mark.api
- async def test_list_projects_with_pagination(self, test_client: AsyncClient):
- """Test project listing with pagination parameters."""
- response = await test_client.get("/api/projects?limit=5&offset=0")
-
- assert response.status_code == 200
- data = response.json()
- assert isinstance(data, list)
- assert len(data) <= 5
-
- @pytest.mark.api
- async def test_get_project_timeline(self, test_client: AsyncClient, sample_project: Project):
- """Test getting detailed project timeline."""
- response = await test_client.get(f"/api/projects/{sample_project.id}/timeline")
-
- assert response.status_code == 200
- data = response.json()
- assert "project" in data
- assert "timeline" in data
- assert isinstance(data["timeline"], list)
-
- @pytest.mark.api
- async def test_get_nonexistent_project_timeline(self, test_client: AsyncClient):
- """Test getting timeline for non-existent project."""
- response = await test_client.get("/api/projects/99999/timeline")
-
- assert response.status_code == 404
-
-
-class TestAnalyticsAPI:
- """Test analytics and insights endpoints."""
-
- @pytest.mark.api
- async def test_get_productivity_metrics(self, test_client: AsyncClient, sample_project: Project):
- """Test getting productivity analytics."""
- response = await test_client.get("/api/analytics/productivity")
-
- assert response.status_code == 200
- data = response.json()
- assert "engagement_score" in data
- assert "average_session_length" in data
- assert "think_time_average" in data
-
- @pytest.mark.api
- async def test_get_productivity_metrics_for_project(self, test_client: AsyncClient, sample_project: Project):
- """Test getting productivity analytics for specific project."""
- response = await test_client.get(f"/api/analytics/productivity?project_id={sample_project.id}")
-
- assert response.status_code == 200
- data = response.json()
- assert isinstance(data, dict)
-
- @pytest.mark.api
- async def test_search_conversations(self, test_client: AsyncClient, sample_conversation):
- """Test searching through conversations."""
- response = await test_client.get("/api/conversations/search?query=implement feature")
-
- assert response.status_code == 200
- data = response.json()
- assert isinstance(data, list)
-
- if data: # If there are results
- result = data[0]
- assert "id" in result
- assert "user_prompt" in result
- assert "relevance_score" in result
-
- @pytest.mark.api
- async def test_search_conversations_with_project_filter(self, test_client: AsyncClient, sample_project: Project):
- """Test searching conversations within a specific project."""
- response = await test_client.get(f"/api/conversations/search?query=debug&project_id={sample_project.id}")
-
- assert response.status_code == 200
- data = response.json()
- assert isinstance(data, list)
-
-
-class TestErrorHandling:
- """Test error handling and edge cases."""
-
- @pytest.mark.api
- async def test_malformed_json(self, test_client: AsyncClient):
- """Test handling of malformed JSON requests."""
- response = await test_client.post(
- "/api/session/start",
- content="{'invalid': json}",
- headers={"Content-Type": "application/json"}
- )
-
- assert response.status_code == 422
-
- @pytest.mark.api
- async def test_missing_required_fields(self, test_client: AsyncClient):
- """Test handling of requests with missing required fields."""
- response = await test_client.post("/api/session/start", json={})
-
- assert response.status_code == 422
- data = response.json()
- assert "detail" in data
-
- @pytest.mark.api
- async def test_invalid_session_id_type(self, test_client: AsyncClient):
- """Test handling of invalid data types."""
- conversation_data = {
- "session_id": "invalid", # Should be int
- "user_prompt": "Test message",
- "exchange_type": "user_prompt"
- }
-
- response = await test_client.post("/api/conversation", json=conversation_data)
-
- assert response.status_code == 422
-
- @pytest.mark.api
- async def test_nonexistent_endpoint(self, test_client: AsyncClient):
- """Test accessing non-existent endpoint."""
- response = await test_client.get("/api/nonexistent")
-
- assert response.status_code == 404
-
-
-class TestIntegrationScenarios:
- """Test complete workflow scenarios."""
-
- @pytest.mark.integration
- async def test_complete_session_workflow(self, test_client: AsyncClient):
- """Test a complete session from start to finish."""
- # Start session
- session_data = TestDataFactory.create_session_data(
- working_directory="/home/user/integration-test"
- )
-
- start_response = await test_client.post("/api/session/start", json=session_data)
- assert start_response.status_code == 201
- session_info = start_response.json()
- session_id = session_info["session_id"]
-
- # Log user prompt
- prompt_data = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:00:00Z",
- "user_prompt": "Help me implement a REST API",
- "exchange_type": "user_prompt"
- }
-
- prompt_response = await test_client.post("/api/conversation", json=prompt_data)
- assert prompt_response.status_code == 201
-
- # Start waiting period
- waiting_start = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:00:01Z",
- "context_before": "Claude is processing the request"
- }
-
- waiting_response = await test_client.post("/api/waiting/start", json=waiting_start)
- assert waiting_response.status_code == 201
-
- # Record some activities
- activities = [
- {
- "session_id": session_id,
- "tool_name": "Write",
- "action": "file_write",
- "file_path": "/home/user/integration-test/api.py",
- "timestamp": "2024-01-01T12:01:00Z",
- "success": True,
- "lines_added": 50
- },
- {
- "session_id": session_id,
- "tool_name": "Edit",
- "action": "file_edit",
- "file_path": "/home/user/integration-test/main.py",
- "timestamp": "2024-01-01T12:02:00Z",
- "success": True,
- "lines_added": 10,
- "lines_removed": 2
- }
- ]
-
- for activity in activities:
- activity_response = await test_client.post("/api/activity", json=activity)
- assert activity_response.status_code == 201
-
- # End waiting period
- waiting_end = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:05:00Z",
- "duration_seconds": 300,
- "context_after": "User reviewed the implementation"
- }
-
- waiting_end_response = await test_client.post("/api/waiting/end", json=waiting_end)
- assert waiting_end_response.status_code == 200
-
- # Record git commit
- git_data = {
- "session_id": session_id,
- "operation": "commit",
- "command": "git commit -m 'Implement REST API'",
- "timestamp": "2024-01-01T12:06:00Z",
- "result": "[main abc123] Implement REST API",
- "success": True,
- "files_changed": ["api.py", "main.py"],
- "lines_added": 60,
- "lines_removed": 2,
- "commit_hash": "abc12345"
- }
-
- git_response = await test_client.post("/api/git", json=git_data)
- assert git_response.status_code == 201
-
- # End session
- end_data = {
- "session_id": session_id,
- "end_reason": "normal"
- }
-
- end_response = await test_client.post("/api/session/end", json=end_data)
- assert end_response.status_code == 200
-
- # Verify project was created and populated
- projects_response = await test_client.get("/api/projects")
- assert projects_response.status_code == 200
- projects = projects_response.json()
-
- # Find our project
- test_project = None
- for project in projects:
- if project["path"] == "/home/user/integration-test":
- test_project = project
- break
-
- assert test_project is not None
- assert test_project["total_sessions"] >= 1
-
- # Get project timeline
- timeline_response = await test_client.get(f"/api/projects/{test_project['id']}/timeline")
- assert timeline_response.status_code == 200
- timeline = timeline_response.json()
-
- assert len(timeline["timeline"]) > 0 # Should have recorded events
-
- @pytest.mark.integration
- @pytest.mark.slow
- async def test_analytics_with_sample_data(self, test_client: AsyncClient, test_db: AsyncSession):
- """Test analytics calculations with realistic sample data."""
- # This test would create a full dataset and verify analytics work correctly
- # Marked as slow since it involves more data processing
-
- productivity_response = await test_client.get("/api/analytics/productivity?days=7")
- assert productivity_response.status_code == 200
-
- metrics = productivity_response.json()
- assert "engagement_score" in metrics
- assert isinstance(metrics["engagement_score"], (int, float))
- assert 0 <= metrics["engagement_score"] <= 100
\ No newline at end of file
diff --git a/tests/test_hooks.py b/tests/test_hooks.py
deleted file mode 100644
index c1f2dd8..0000000
--- a/tests/test_hooks.py
+++ /dev/null
@@ -1,469 +0,0 @@
-"""
-Tests for Claude Code hook simulation and integration.
-"""
-
-import pytest
-import json
-import subprocess
-from unittest.mock import patch, MagicMock
-from httpx import AsyncClient
-
-from tests.fixtures import TestDataFactory
-
-
-class TestHookSimulation:
- """Test hook payload generation and API integration."""
-
- def test_session_start_hook_payload(self):
- """Test generating SessionStart hook payload."""
- # Simulate environment variables that would be set by Claude Code
- mock_env = {
- "PWD": "/home/user/test-project",
- "USER": "testuser"
- }
-
- with patch.dict("os.environ", mock_env):
- with patch("subprocess.check_output") as mock_git:
- # Mock git commands
- mock_git.side_effect = [
- b"main\n", # git branch --show-current
- b"https://github.com/user/test-project.git\n" # git config --get remote.origin.url
- ]
-
- payload = {
- "session_type": "startup",
- "working_directory": mock_env["PWD"],
- "git_branch": "main",
- "git_repo": "https://github.com/user/test-project.git",
- "environment": {
- "pwd": mock_env["PWD"],
- "user": mock_env["USER"],
- "timestamp": "2024-01-01T12:00:00Z"
- }
- }
-
- # Verify payload structure matches API expectations
- assert "session_type" in payload
- assert "working_directory" in payload
- assert payload["session_type"] in ["startup", "resume", "clear"]
-
- def test_user_prompt_hook_payload(self):
- """Test generating UserPromptSubmit hook payload."""
- mock_prompt = "How do I implement user authentication?"
- mock_session_id = "123"
-
- payload = {
- "session_id": int(mock_session_id),
- "timestamp": "2024-01-01T12:00:00Z",
- "user_prompt": mock_prompt,
- "exchange_type": "user_prompt"
- }
-
- assert payload["session_id"] == 123
- assert payload["user_prompt"] == mock_prompt
- assert payload["exchange_type"] == "user_prompt"
-
- def test_post_tool_use_edit_payload(self):
- """Test generating PostToolUse Edit hook payload."""
- mock_file_path = "/home/user/test-project/main.py"
- mock_session_id = "123"
-
- payload = {
- "session_id": int(mock_session_id),
- "tool_name": "Edit",
- "action": "file_edit",
- "file_path": mock_file_path,
- "timestamp": "2024-01-01T12:00:00Z",
- "metadata": {"success": True},
- "success": True
- }
-
- assert payload["tool_name"] == "Edit"
- assert payload["file_path"] == mock_file_path
- assert payload["success"] is True
-
- def test_post_tool_use_bash_payload(self):
- """Test generating PostToolUse Bash hook payload."""
- mock_command = "pytest --cov=app"
- mock_session_id = "123"
-
- payload = {
- "session_id": int(mock_session_id),
- "tool_name": "Bash",
- "action": "command_execution",
- "timestamp": "2024-01-01T12:00:00Z",
- "metadata": {
- "command": mock_command,
- "success": True
- },
- "success": True
- }
-
- assert payload["tool_name"] == "Bash"
- assert payload["metadata"]["command"] == mock_command
-
- def test_notification_hook_payload(self):
- """Test generating Notification hook payload."""
- mock_session_id = "123"
-
- payload = {
- "session_id": int(mock_session_id),
- "timestamp": "2024-01-01T12:00:00Z",
- "context_before": "Claude is waiting for input"
- }
-
- assert payload["session_id"] == 123
- assert "context_before" in payload
-
- def test_stop_hook_payload(self):
- """Test generating Stop hook payload."""
- mock_session_id = "123"
-
- payload = {
- "session_id": int(mock_session_id),
- "timestamp": "2024-01-01T12:00:00Z",
- "claude_response": "Response completed",
- "exchange_type": "claude_response"
- }
-
- assert payload["exchange_type"] == "claude_response"
-
- def test_json_escaping_in_payloads(self):
- """Test that special characters in payloads are properly escaped."""
- # Test prompt with quotes and newlines
- problematic_prompt = 'How do I handle "quotes" and\nnewlines in JSON?'
-
- payload = {
- "session_id": 1,
- "user_prompt": problematic_prompt,
- "exchange_type": "user_prompt"
- }
-
- # Should be able to serialize to JSON without errors
- json_str = json.dumps(payload)
- parsed = json.loads(json_str)
-
- assert parsed["user_prompt"] == problematic_prompt
-
- def test_file_path_escaping(self):
- """Test that file paths with spaces are handled correctly."""
- file_path_with_spaces = "/home/user/My Projects/test project/main.py"
-
- payload = {
- "session_id": 1,
- "tool_name": "Edit",
- "file_path": file_path_with_spaces
- }
-
- json_str = json.dumps(payload)
- parsed = json.loads(json_str)
-
- assert parsed["file_path"] == file_path_with_spaces
-
-
-class TestHookIntegration:
- """Test actual hook integration with the API."""
-
- @pytest.mark.hooks
- async def test_session_start_hook_integration(self, test_client: AsyncClient):
- """Test complete SessionStart hook workflow."""
- # Simulate the payload that would be sent by the hook
- hook_payload = TestDataFactory.create_session_data(
- session_type="startup",
- working_directory="/home/user/hook-test",
- git_branch="main",
- git_repo="https://github.com/user/hook-test.git"
- )
-
- response = await test_client.post("/api/session/start", json=hook_payload)
-
- assert response.status_code == 201
- data = response.json()
- assert "session_id" in data
- assert "project_id" in data
-
- # Store session ID for subsequent hook calls
- return data["session_id"]
-
- @pytest.mark.hooks
- async def test_user_prompt_hook_integration(self, test_client: AsyncClient):
- """Test UserPromptSubmit hook integration."""
- # First create a session
- session_id = await self.test_session_start_hook_integration(test_client)
-
- # Simulate user prompt hook
- hook_payload = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:00:00Z",
- "user_prompt": "This prompt came from a hook",
- "exchange_type": "user_prompt"
- }
-
- response = await test_client.post("/api/conversation", json=hook_payload)
-
- assert response.status_code == 201
-
- @pytest.mark.hooks
- async def test_post_tool_use_hook_integration(self, test_client: AsyncClient):
- """Test PostToolUse hook integration."""
- session_id = await self.test_session_start_hook_integration(test_client)
-
- # Simulate Edit tool hook
- hook_payload = {
- "session_id": session_id,
- "tool_name": "Edit",
- "action": "file_edit",
- "file_path": "/home/user/hook-test/main.py",
- "timestamp": "2024-01-01T12:01:00Z",
- "metadata": {"lines_changed": 5},
- "success": True,
- "lines_added": 3,
- "lines_removed": 2
- }
-
- response = await test_client.post("/api/activity", json=hook_payload)
-
- assert response.status_code == 201
-
- @pytest.mark.hooks
- async def test_waiting_period_hook_integration(self, test_client: AsyncClient):
- """Test Notification and waiting period hooks."""
- session_id = await self.test_session_start_hook_integration(test_client)
-
- # Start waiting period
- start_payload = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:00:00Z",
- "context_before": "Claude finished responding"
- }
-
- start_response = await test_client.post("/api/waiting/start", json=start_payload)
- assert start_response.status_code == 201
-
- # End waiting period
- end_payload = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:05:00Z",
- "duration_seconds": 300,
- "context_after": "User submitted new prompt"
- }
-
- end_response = await test_client.post("/api/waiting/end", json=end_payload)
- assert end_response.status_code == 200
-
- @pytest.mark.hooks
- async def test_stop_hook_integration(self, test_client: AsyncClient):
- """Test Stop hook integration."""
- session_id = await self.test_session_start_hook_integration(test_client)
-
- # Simulate Stop hook (Claude response)
- hook_payload = {
- "session_id": session_id,
- "timestamp": "2024-01-01T12:10:00Z",
- "claude_response": "Here's the implementation you requested...",
- "tools_used": ["Edit", "Write"],
- "files_affected": ["main.py", "utils.py"],
- "exchange_type": "claude_response"
- }
-
- response = await test_client.post("/api/conversation", json=hook_payload)
-
- assert response.status_code == 201
-
- @pytest.mark.hooks
- async def test_git_hook_integration(self, test_client: AsyncClient):
- """Test git operation hook integration."""
- session_id = await self.test_session_start_hook_integration(test_client)
-
- hook_payload = TestDataFactory.create_git_operation_data(
- session_id=session_id,
- operation="commit",
- command="git commit -m 'Test commit from hook'",
- files_changed=["main.py"],
- lines_added=10,
- lines_removed=2
- )
-
- response = await test_client.post("/api/git", json=hook_payload)
-
- assert response.status_code == 201
-
-
-class TestHookEnvironment:
- """Test hook environment and configuration."""
-
- def test_session_id_persistence(self):
- """Test session ID storage and retrieval mechanism."""
- session_file = "/tmp/claude-session-id"
- test_session_id = "12345"
-
- # Simulate writing session ID to file (as hooks would do)
- with open(session_file, "w") as f:
- f.write(test_session_id)
-
- # Simulate reading session ID from file (as subsequent hooks would do)
- with open(session_file, "r") as f:
- retrieved_id = f.read().strip()
-
- assert retrieved_id == test_session_id
-
- # Clean up
- import os
- if os.path.exists(session_file):
- os.remove(session_file)
-
- def test_git_environment_detection(self):
- """Test git repository detection logic."""
- with patch("subprocess.check_output") as mock_subprocess:
- # Mock successful git commands
- mock_subprocess.side_effect = [
- b"main\n", # git branch --show-current
- b"https://github.com/user/repo.git\n" # git config --get remote.origin.url
- ]
-
- # Simulate what hooks would do
- try:
- branch = subprocess.check_output(
- ["git", "branch", "--show-current"],
- stderr=subprocess.DEVNULL,
- text=True
- ).strip()
-
- repo = subprocess.check_output(
- ["git", "config", "--get", "remote.origin.url"],
- stderr=subprocess.DEVNULL,
- text=True
- ).strip()
-
- assert branch == "main"
- assert repo == "https://github.com/user/repo.git"
-
- except subprocess.CalledProcessError:
- # If git commands fail, hooks should handle gracefully
- branch = "unknown"
- repo = "null"
-
- # Test non-git directory handling
- with patch("subprocess.check_output", side_effect=subprocess.CalledProcessError(128, "git")):
- try:
- branch = subprocess.check_output(
- ["git", "branch", "--show-current"],
- stderr=subprocess.DEVNULL,
- text=True
- ).strip()
- except subprocess.CalledProcessError:
- branch = "unknown"
-
- assert branch == "unknown"
-
- def test_hook_error_handling(self):
- """Test hook error handling and graceful failures."""
- # Test network failure (API unreachable)
- import requests
- from unittest.mock import patch
-
- with patch("requests.post", side_effect=requests.exceptions.ConnectionError("Connection refused")):
- # Hooks should not crash if API is unreachable
- # This would be handled by curl in the actual hooks with > /dev/null 2>&1
- try:
- # Simulate what would happen in a hook
- response = requests.post("http://localhost:8000/api/session/start", json={})
- assert False, "Should have raised ConnectionError"
- except requests.exceptions.ConnectionError:
- # This is expected - hook should handle gracefully
- pass
-
- def test_hook_command_construction(self):
- """Test building hook commands with proper escaping."""
- # Test session start hook command construction
- session_data = {
- "session_type": "startup",
- "working_directory": "/home/user/test project", # Space in path
- "git_branch": "feature/new-feature",
- "environment": {"user": "testuser"}
- }
-
- # Construct JSON payload like the hook would
- json_payload = json.dumps(session_data)
-
- # Verify it can be parsed back
- parsed = json.loads(json_payload)
- assert parsed["working_directory"] == "/home/user/test project"
-
- def test_hook_timing_and_ordering(self):
- """Test that hook timing and ordering work correctly."""
- # Simulate rapid-fire hook calls (as would happen during active development)
- timestamps = [
- "2024-01-01T12:00:00Z", # Session start
- "2024-01-01T12:00:01Z", # User prompt
- "2024-01-01T12:00:02Z", # Waiting start
- "2024-01-01T12:00:05Z", # Tool use (Edit)
- "2024-01-01T12:00:06Z", # Tool use (Write)
- "2024-01-01T12:00:10Z", # Waiting end
- "2024-01-01T12:00:11Z", # Claude response
- ]
-
- # Verify timestamps are in chronological order
- for i in range(1, len(timestamps)):
- assert timestamps[i] > timestamps[i-1]
-
-
-class TestHookConfiguration:
- """Test hook configuration validation and setup."""
-
- def test_hook_config_validation(self):
- """Test validation of hook configuration JSON."""
- # Load and validate the provided hook configuration
- with open("config/claude-hooks.json", "r") as f:
- config = json.load(f)
-
- # Verify required hook types are present
- required_hooks = ["SessionStart", "UserPromptSubmit", "PostToolUse", "Notification", "Stop"]
- for hook_type in required_hooks:
- assert hook_type in config["hooks"]
-
- # Verify SessionStart has all session types
- session_start_hooks = config["hooks"]["SessionStart"]
- matchers = [hook.get("matcher") for hook in session_start_hooks if "matcher" in hook]
- assert "startup" in matchers
- assert "resume" in matchers
- assert "clear" in matchers
-
- # Verify PostToolUse has main tools
- post_tool_hooks = config["hooks"]["PostToolUse"]
- tool_matchers = [hook.get("matcher") for hook in post_tool_hooks if "matcher" in hook]
- assert "Edit" in tool_matchers
- assert "Write" in tool_matchers
- assert "Read" in tool_matchers
- assert "Bash" in tool_matchers
-
- def test_hook_command_structure(self):
- """Test that hook commands have proper structure."""
- with open("config/claude-hooks.json", "r") as f:
- config = json.load(f)
-
- for hook_type, hooks in config["hooks"].items():
- for hook in hooks:
- assert "command" in hook
- command = hook["command"]
-
- # All commands should make HTTP requests to localhost:8000
- assert "http://localhost:8000" in command
- assert "curl" in command
-
- # Commands should run in background and suppress output
- assert "> /dev/null 2>&1 &" in command
-
- def test_session_id_handling_in_config(self):
- """Test that hook configuration properly handles session ID."""
- with open("config/claude-hooks.json", "r") as f:
- config = json.load(f)
-
- # Non-SessionStart hooks should use session ID from temp file
- for hook_type, hooks in config["hooks"].items():
- if hook_type != "SessionStart":
- for hook in hooks:
- command = hook["command"]
- # Should reference the session ID temp file
- assert "CLAUDE_SESSION_FILE" in command
- assert "/tmp/claude-session-id" in command
\ No newline at end of file