CodeToMarkdown - Technical Documentation

Table of Contents

1. Project Overview
2. Architecture Overview
3. Key Components
4. Authentication & Authorization
5. CLI Commands
6. Database Schema
7. External Services
8. Usage Examples
9. Installation & Setup

Project Overview

CodeToMarkdown is a web-based documentation generation platform built on CodeIgniter 4. The application allows users to upload code files and automatically generates comprehensive documentation using AI-powered analysis. The system provides user management, billing integration, and progress tracking for documentation generation tasks.

Key Features

• Automated Documentation Generation: Upload code files and generate markdown documentation
• User Management: Registration, authentication, and user roles
• Billing Integration: PayPal integration for premium features
• Progress Tracking: Real-time status updates for documentation jobs
• Admin Dashboard: User management and system administration
• Multi-timezone Support: User-specific timezone handling

Architecture Overview

The application follows the Model-View-Controller (MVC) pattern with additional service layers:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Web Interface │    │   CLI Commands  │    │  External APIs  │
│   (Views)       │    │                 │    │  (Claude AI)    │
└─────────┬───────┘    └─────────┬───────┘    └─────────┬───────┘
          │                      │                      │
          ▼                      ▼                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Controllers Layer                            │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ Home Controller │ Upload          │ Documentation Controller    │
│ Auth Controller │ Controller      │ Admin Controller            │
│ Account         │ Dashboard       │ Billing Controller          │
└─────────┬───────┴─────────┬───────┴─────────┬───────────────────┘
          │                 │                 │
          ▼                 ▼                 ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Services Layer                               │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ ClaudeService   │ PayPalService   │ Authentication Services     │
└─────────┬───────┴─────────┬───────┴─────────┬───────────────────┘
          │                 │                 │
          ▼                 ▼                 ▼
┌─────────────────────────────────────────────────────────────────┐
│                     Models Layer                                │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ ProcessingModel │ TransactionModel│ CustomUserModel             │
└─────────┬───────┴─────────┬───────┴─────────┬───────────────────┘
          │                 │                 │
          ▼                 ▼                 ▼
┌─────────────────────────────────────────────────────────────────┐
│                     Database Layer                              │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐               │
│  │ processing_ │ │ transactions│ │ auth_*      │               │
│  │ jobs        │ │             │ │ tables      │               │
│  └─────────────┘ └─────────────┘ └─────────────┘               │
└─────────────────────────────────────────────────────────────────┘

Key Components

Controllers

Home Controller (app/Controllers/Home.php)

• Purpose: Handles the main landing page and initial user interactions
• Responsibilities: Display homepage, handle basic navigation

Upload Controller (app/Controllers/Upload.php)

• Purpose: Manages file uploads and processing initiation
• Key Features:

- File upload validation

- Processing job creation

- Progress tracking

- Results display

Documentation Controller (app/Controllers/Documentation.php)

• Purpose: Core documentation generation logic
• Key Methods:

- generateDocs($fileId): Main documentation generation method

- Integration with ClaudeService for AI-powered analysis

Admin Controller (app/Controllers/Admin.php)

• Purpose: Administrative interface for user and system management
• Features:

- User management

- System monitoring

- Processing job oversight

Authentication Controller (app/Controllers/AuthCtrlr.php)

• Purpose: Custom authentication handling beyond CodeIgniter Shield
• Features:

- Custom login/logout flows

- User registration enhancements

Models

ProcessingModel (app/Models/ProcessingModel.php)

// Key fields and relationships
class ProcessingModel extends Model
{
    protected $table = 'processing_jobs';
    protected $allowedFields = [
        'user_id',
        'file_name', 
        'file_path',
        'status',
        'progress',
        'result_path',
        'error_message',
        'created_at',
        'updated_at',
        'expired_at'
    ];
}

CustomUserModel (app/Models/CustomUserModel.php)

• Purpose: Extended user model with additional features
• Features: Token management, timezone support, custom user data

TransactionModel (app/Models/TransactionModel.php)

• Purpose: Financial transaction tracking
• Features: PayPal integration, billing history, token purchases

Services

ClaudeService (app/Libraries/ClaudeService.php)

• Purpose: Integration with Claude AI API for documentation generation
• Key Features:

- Code analysis

- Documentation generation

- Error handling and retry logic

PayPalService (app/Libraries/PayPalService.php)

• Purpose: PayPal payment processing
• Features:

- Payment creation

- Transaction verification

- Webhook handling

Authentication & Authorization

The application uses CodeIgniter Shield with custom extensions:

User Groups

• superadmin: Complete system control
• admin: Day-to-day administration
• developer: Development access with beta features
• user: Standard user (default)
• beta: Beta feature access

Permissions Matrix

'superadmin' => ['admin.*', 'users.*', 'beta.*'],
'admin' => ['admin.access', 'users.create', 'users.edit', 'users.delete', 'beta.access'],
'developer' => ['admin.access', 'admin.settings', 'users.create', 'users.edit', 'beta.access'],
'user' => [],
'beta' => ['beta.access']

Filters

• AuthFilter: Ensures user authentication
• AdminFilter: Restricts admin area access

CLI Commands

DocumentationGenerate Command

php spark documentation:generate [file_id]

Purpose: Processes uploaded files and generates documentation Usage Example:

php spark documentation:generate 123

Implementation:

public function run(array $params)
{
    $fileId = $params[0];
    $docController = new \App\Controllers\Documentation();
    $docController->generateDocs($fileId);
    CLI::write("Documentation generation completed successfully.", 'green');
}

UpdateUserIds Command

php spark update:userids

Purpose: Migration utility to assign user IDs to existing processing jobs Use Case: Database maintenance after schema updates

Database Schema

Processing Jobs Table

CREATE TABLE processing_jobs (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT,
    file_name VARCHAR(255),
    file_path VARCHAR(500),
    status ENUM('pending', 'processing', 'completed', 'failed'),
    progress INT DEFAULT 0,
    result_path VARCHAR(500),
    error_message TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    expired_at TIMESTAMP NULL
);

Transactions Table

CREATE TABLE transactions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT,
    transaction_id VARCHAR(255),
    amount DECIMAL(10,2),
    currency VARCHAR(3),
    status VARCHAR(50),
    tokens_purchased INT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Migration Files

• 2025-06-07-014458_CreateProcessingJobsTable.php: Initial processing jobs table
• 2025-06-07-131900_AddUserIdToProcessingJobs.php: User association
• 2025-06-07-145041_AddTokensToUsers.php: Token system
• 2025-06-07-145116_CreateTransactionsTable.php: Financial transactions

External Services

Claude AI Integration

class ClaudeService
{
    public function generateDocumentation($codeContent, $fileName)
    {
        // API call to Claude AI
        // Process response
        // Return formatted documentation
    }
}

PayPal Integration

class PayPalService  
{
    public function createOrder($amount, $currency = 'USD')
    {
        // Create PayPal order
        // Return order details
    }
    public function capturePayment($orderId)
    {
        // Capture payment
        // Update transaction records
    }
}

Usage Examples

File Upload and Processing

// 1. User uploads file through web interface
// 2. Upload controller validates and stores file
$uploadController = new Upload();
$result = $uploadController->process();
// 3. CLI command processes the file
exec("php spark documentation:generate {$fileId}");
// 4. User views results
redirect("/results/{$fileId}");

User Registration with Tokens

// New user registration
$user = new CustomUserModel();
$userData = [
    'email' => $email,
    'password' => $hashedPassword,
    'tokens' => 3, // Free tokens for new users
    'timezone' => $userTimezone
];
$user->save($userData);

Admin User Management

// Admin viewing users
if (auth()->user()->can('admin.access')) {
    $users = $userModel->findAll();
    return view('admin/users', ['users' => $users]);
}

Installation & Setup

Prerequisites

• PHP 8.1+
• MySQL 8.0+
• Composer
• Web server (Apache/Nginx)

Installation Steps

1. Clone Repository

git clone <repository-url>
cd codetomarkdown

1. Install Dependencies

composer install

1. Environment Configuration

cp env .env

Edit .env with your configuration:

database.default.hostname = localhost
database.default.database = codetomarkdown
database.default.username = your_username
database.default.password = your_password
# Claude AI API
CLAUDE_API_KEY = your_claude_api_key
# PayPal Configuration  
PAYPAL_CLIENT_ID = your_paypal_client_id
PAYPAL_CLIENT_SECRET = your_paypal_client_secret
PAYPAL_MODE = sandbox # or live

1. Database Setup

php spark migrate
php spark db:seed UpdatePendingTransactions

1. Set Permissions

chmod -R 755 writable/
chmod -R 755 public/uploads/

1. Create Admin User

php spark shield:user create
php spark shield:user activate [user_id]
php spark shield:user addgroup [user_id] superadmin

Development Setup

For development environment:

# Enable debug mode
# Edit app/Config/Boot/development.php (already configured)
# Start development server
php spark serve
# Watch for file changes (if using build tools)
npm run dev

Production Deployment

1. Web Server Configuration

- Point document root to public/ directory

- Configure URL rewriting for CodeIgniter

1. Security Settings

// app/Config/App.php
public bool $forceGlobalSecureRequests = true;
public string $baseURL = 'https://your-domain.com/';

1. Cron Jobs

# Add to crontab for background processing
*/5 * * * * cd /path/to/app && php spark queue:process

Troubleshooting

Common Issues:

• File upload failures: Check php.ini settings for upload_max_filesize and post_max_size
• Permission errors: Ensure writable/ directory has proper permissions
• Database connection: Verify database credentials and server accessibility
• External API failures: Check API keys and network connectivity

Logs Location:

• Application logs: writable/logs/
• Error logs: Web server error logs
• Debug information: Available in development mode

This documentation provides a comprehensive overview of the CodeToMarkdown application architecture and implementation details. For specific implementation questions or advanced configuration, refer to the individual component files and CodeIgniter 4 documentation.