Engine.

The pitch

Everything Engine does

Autoblogging done responsibly: your prompts, your editorial gates, your provider keys — with the machinery to run it hands-free once you trust it.

Chapter 1

The campaign model: recipes, not buttons

The core abstraction is the campaign — a stored recipe that says what to write about (keywords), how to write it (prompt, personality, format, length, variations), who writes it (provider + model), where it lands (category rules, post status) and when (schedule). Once saved, the campaign runs itself; you manage recipes, not posts.

That one design decision shapes everything else in the plugin: campaigns are rows, runs are queue items, and every action is logged against its campaign — so "why did this post happen?" always has an answer.

Chapter 2

Four tables: campaigns, queue, logs, keys

Engine's state lives in four custom tables: awp_campaigns (the recipes, with status and next-run time), awp_content_queue (every generated piece and its lifecycle), awp_activity_logs (who did what, when, with what result) and awp_api_keys (encrypted provider credentials).

CREATE TABLE wp_awp_campaigns (
  id bigint(20) UNSIGNED NOT NULL AUTO_INCREMENT,
  name varchar(255) NOT NULL,
  type varchar(50) NOT NULL,
  status varchar(20) NOT NULL DEFAULT 'active',
  settings longtext,                -- the whole recipe, JSON
  next_run datetime DEFAULT NULL,   -- the clock
  PRIMARY KEY (id),
  KEY status (status),
  KEY next_run (next_run)
);

The next_run index is the heartbeat: the cron worker asks one cheap question — "which active campaigns are due?" — and the database answers from the index. Settings are a JSON blob on purpose: campaign options evolve fast, and schema migrations for every new toggle would be madness.

Chapter 3

The provider factory: five AIs, one interface

OpenAI, Claude, Gemini, Grok and DeepSeek all speak different dialects of "give me an article". Engine hides that behind one abstract class — each provider implements generate_content(), and shared logic (prompt building, JSON parsing, error normalisation) lives in the parent.

abstract class AIPT_Engine_AI_Provider {
    abstract public function generate_content( $prompt, $args );
    // shared: build_prompt(), parse_json_response(), error handling
}

class AIPT_Engine_AI_Factory {
    public static function create( $provider = 'google_gemini', $model = null ) {
        switch ( $provider ) {
            case 'openai':   return new AIPT_Engine_OpenAI( $model );
            case 'claude':   return new AIPT_Engine_Claude( $model );
            case 'grok':     return new AIPT_Engine_Grok( $model );
            case 'deepseek': return new AIPT_Engine_DeepSeek( $model );
            default:         return new AIPT_Engine_Gemini( $model );
        }
    }
}

Adding a sixth provider is a ~50-line subclass and one case. The campaign UI reads the provider list dynamically, so new engines appear in the dropdown automatically. This is the open/closed principle earning its keep in WordPress.

Chapter 4

API keys: encrypted at rest, tested before use

API keys are credentials with a credit card attached — storing them as plain options is negligence. Engine generates a per-site 256-bit key on activation and encrypts every provider key with AES-256-CBC and a random IV before it touches the database.

$iv        = openssl_random_pseudo_bytes( 16 );
$encrypted = openssl_encrypt( $key, 'aes-256-cbc',
                              AIPT_ENGINE_ENCRYPTION_KEY, 0, $iv );
// store iv + ciphertext; decrypt only in memory, only when calling the API

Chapter 5

The queue & three cron workers

Generation is slow (an AI round-trip can take 30+ seconds) so nothing generates inside a page request. Three WP-Cron workers split the labour:

1. awp_check_campaigns (hourly) — finds campaigns whose next_run has passed, asks the provider for content, and files the result in the queue as pending. Duplicate titles are detected and skipped with a logged warning.
2. awp_process_queue (hourly, offset) — takes approved items, creates the WordPress post (draft or publish per campaign), attaches images, schema and snippets, and marks the item completed — or failed with the exact error message for retry.
3. awp_cleanup_logs (daily) — prunes old activity logs so the table never becomes the biggest thing in your database.

The status flow — pending → approved → completed / failed — is the editorial gate: in review mode a human clicks approve; in full-auto the processor approves its own work. Either way the audit log records it.

Chapter 6

Publishing extras: images, schema, snippets

A wall of AI text isn't a post. When a queue item publishes, Engine also:

1. Generates a featured image via DALL·E — with an automatic Pexels stock-photo fallback when image generation fails or is disabled, so posts never ship naked.
2. Attaches SEO schema — a JSON-LD block stored in post meta and injected on render, so generated articles arrive structured-data-ready.
3. Writes social snippets — short share-ready blurbs stored alongside the post, one less thing to write when you promote it.
4. Tags its work — every generated post carries a meta flag, so you can query, audit or bulk-manage AI content separately from human writing. Transparency is a feature.

Chapter 7

Mission control: dashboard, calendar, logs

Six admin screens in the suite's shared dark/light theme: a dashboard with campaign health and recent activity; campaigns for creating and managing recipes; the queue with inline approve/edit/reject; an editorial calendar showing what's scheduled to land when; logs for the full audit trail; and settings for provider keys (with a test button that verifies a key against the live API before you bet a campaign on it).

The calendar is the sleeper feature: autoblogging goes wrong when you lose track of volume. Seeing next week as a grid — three posts Tuesday, nothing Thursday — turns a firehose into an editorial plan.

Chapter 8

Shipping it — including the scars

Plus the standing checklist: prepared statements, nonce + capability checks on every AJAX action, escaped output, sanitised campaign settings, translation-ready strings, and cron events cleared on deactivation.

Make it yours

Rebrand it. Seriously, we encourage it.

The rename map for Engine — change these consistently (and read Scar #1 and #2 first):