feat: adds all enums

Author: JasonTheAdams

src/Common/AbstractEnum.php

@@ -0,0 +1,229 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Common;
+
+use BadMethodCallException;
+use InvalidArgumentException;
+use ReflectionClass;
+
+/**
+ * Abstract base class for enum-like behavior in PHP 7.4
+ *
+ * This class provides enum-like functionality for PHP versions that don't support native enums.
+ * Child classes should define uppercase snake_case constants for enum values.
+ *
+ * @example
+ * class PersonEnum extends AbstractEnum {
+ *     public const FIRST_NAME = 'first';
+ *     public const LAST_NAME = 'last';
+ * }
+ *
+ * // Usage:
+ * $enum = PersonEnum::firstName(); // Creates instance with value 'first'
+ * $enum->isFirstName(); // Returns true
+ * $enum->equals('first'); // Returns true
+ * $enum->is(PersonEnum::firstName()); // Returns true
+ */
+abstract class AbstractEnum
+{
+    /**
+     * @var string|int|float The value of the enum instance
+     */
+    private $value;
+
+    /**
+     * @var array<string, array<string, string|int|float>> Cache for reflection data
+     */
+    private static $cache = [];
+
+    /**
+     * Constructor is private to ensure instances are created through static methods
+     *
+     * @param string|int|float $value The enum value
+     */
+    private function __construct($value)
+    {
+        $this->value = $value;
+    }
+
+    /**
+     * Get the value of the enum instance
+     *
+     * @return string|int|float
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Check if this enum has the same value as the given value
+     *
+     * @param string|int|float|self $other The value or enum to compare
+     * @return bool
+     */
+    public function equals($other): bool
+    {
+        if ($other instanceof self) {
+            return $this->is($other);
+        }
+
+        return $this->value === $other;
+    }
+
+    /**
+     * Check if this enum is the same instance type and value as another enum
+     *
+     * @param self $other The other enum to compare
+     * @return bool
+     */
+    public function is(self $other): bool
+    {
+        return get_class($this) === get_class($other) && $this->value === $other->getValue();
+    }
+
+    /**
+     * Get all valid values for this enum
+     *
+     * @return array<string, string|int|float>
+     */
+    public static function getValues(): array
+    {
+        return self::getConstants();
+    }
+
+    /**
+     * Check if a value is valid for this enum
+     *
+     * @param string|int|float $value The value to check
+     * @return bool
+     */
+    public static function isValidValue($value): bool
+    {
+        return in_array($value, self::getValues(), true);
+    }
+
+    /**
+     * Create an enum instance from a value
+     *
+     * @param string|int|float $value The enum value
+     * @return static
+     * @throws InvalidArgumentException If the value is not valid
+     */
+    public static function fromValue($value): self
+    {
+        if (!self::isValidValue($value)) {
+            throw new InvalidArgumentException(
+                sprintf('Invalid value "%s" for enum %s', (string) $value, static::class)
+            );
+        }
+
+        $className = static::class;
+        return new $className($value);
+    }
+
+    /**
+     * Get all constants for this enum class
+     *
+     * @return array<string, string|int|float>
+     */
+    protected static function getConstants(): array
+    {
+        $className = static::class;
+
+        if (!isset(self::$cache[$className])) {
+            $reflection = new ReflectionClass($className);
+            $constants = $reflection->getConstants();
+
+            // Filter to only include uppercase snake_case constants
+            $enumConstants = [];
+            foreach ($constants as $name => $value) {
+                if (
+                    preg_match('/^[A-Z][A-Z0-9_]*$/', $name)
+                    && (is_string($value) || is_int($value) || is_float($value))
+                ) {
+                    $enumConstants[$name] = $value;
+                }
+            }
+
+            self::$cache[$className] = $enumConstants;
+        }
+
+        return self::$cache[$className];
+    }
+
+    /**
+     * Handle dynamic method calls for enum creation and checking
+     *
+     * @param string $name The method name
+     * @param array<mixed> $arguments The method arguments
+     * @return bool
+     * @throws BadMethodCallException If the method doesn't exist
+     */
+    public function __call(string $name, array $arguments)
+    {
+        // Handle is* methods
+        if (strpos($name, 'is') === 0) {
+            $constantName = self::camelCaseToConstant(substr($name, 2));
+            $constants = self::getConstants();
+
+            if (isset($constants[$constantName])) {
+                return $this->value === $constants[$constantName];
+            }
+        }
+
+        throw new BadMethodCallException(
+            sprintf('Method %s::%s does not exist', static::class, $name)
+        );
+    }
+
+    /**
+     * Handle static method calls for enum creation
+     *
+     * @param string $name The method name
+     * @param array<mixed> $arguments The method arguments
+     * @return static
+     * @throws BadMethodCallException If the method doesn't exist
+     */
+    public static function __callStatic(string $name, array $arguments)
+    {
+        $constantName = self::camelCaseToConstant($name);
+        $constants = self::getConstants();
+
+        if (isset($constants[$constantName])) {
+            $className = static::class;
+            return new $className($constants[$constantName]);
+        }
+
+        throw new BadMethodCallException(
+            sprintf('Method %s::%s does not exist', static::class, $name)
+        );
+    }
+
+    /**
+     * Convert camelCase to CONSTANT_CASE
+     *
+     * @param string $camelCase The camelCase string
+     * @return string The CONSTANT_CASE version
+     */
+    private static function camelCaseToConstant(string $camelCase): string
+    {
+        $snakeCase = preg_replace('/([a-z])([A-Z])/', '$1_$2', $camelCase);
+        if ($snakeCase === null) {
+            return strtoupper($camelCase);
+        }
+        return strtoupper($snakeCase);
+    }
+
+    /**
+     * String representation of the enum
+     *
+     * @return string
+     */
+    public function __toString(): string
+    {
+        return (string) $this->value;
+    }
+}

src/Messages/Enums/MessagePartTypeEnum.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Messages\Enums;
+
+use WordPress\AiClient\Common\AbstractEnum;
+
+/**
+ * Enum for message part types
+ *
+ * @method static self text() Create an instance for TEXT type
+ * @method static self inlineFile() Create an instance for INLINE_FILE type
+ * @method static self remoteFile() Create an instance for REMOTE_FILE type
+ * @method static self functionCall() Create an instance for FUNCTION_CALL type
+ * @method static self functionResponse() Create an instance for FUNCTION_RESPONSE type
+ * @method bool isText() Check if the type is TEXT
+ * @method bool isInlineFile() Check if the type is INLINE_FILE
+ * @method bool isRemoteFile() Check if the type is REMOTE_FILE
+ * @method bool isFunctionCall() Check if the type is FUNCTION_CALL
+ * @method bool isFunctionResponse() Check if the type is FUNCTION_RESPONSE
+ */
+class MessagePartTypeEnum extends AbstractEnum
+{
+    /**
+     * Text content
+     */
+    public const TEXT = 'text';
+
+    /**
+     * Inline file content (base64 encoded)
+     */
+    public const INLINE_FILE = 'inline_file';
+
+    /**
+     * Remote file reference (URL)
+     */
+    public const REMOTE_FILE = 'remote_file';
+
+    /**
+     * Function call request
+     */
+    public const FUNCTION_CALL = 'function_call';
+
+    /**
+     * Function response
+     */
+    public const FUNCTION_RESPONSE = 'function_response';
+}

src/Messages/Enums/MessageRoleEnum.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Messages\Enums;
+
+use WordPress\AiClient\Common\AbstractEnum;
+
+/**
+ * Enum for message roles in AI conversations
+ *
+ * @method static self user() Create an instance for USER role
+ * @method static self model() Create an instance for MODEL role
+ * @method static self system() Create an instance for SYSTEM role
+ * @method bool isUser() Check if the role is USER
+ * @method bool isModel() Check if the role is MODEL
+ * @method bool isSystem() Check if the role is SYSTEM
+ */
+class MessageRoleEnum extends AbstractEnum
+{
+    /**
+     * User role - messages from the user
+     */
+    public const USER = 'user';
+
+    /**
+     * Model role - messages from the AI model
+     */
+    public const MODEL = 'model';
+
+    /**
+     * System role - system instructions
+     */
+    public const SYSTEM = 'system';
+}

src/Messages/Enums/ModalityEnum.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WordPress\AiClient\Messages\Enums;
+
+use WordPress\AiClient\Common\AbstractEnum;
+
+/**
+ * Enum for input/output modalities
+ *
+ * @method static self text() Create an instance for TEXT modality
+ * @method static self document() Create an instance for DOCUMENT modality
+ * @method static self image() Create an instance for IMAGE modality
+ * @method static self audio() Create an instance for AUDIO modality
+ * @method static self video() Create an instance for VIDEO modality
+ * @method bool isText() Check if the modality is TEXT
+ * @method bool isDocument() Check if the modality is DOCUMENT
+ * @method bool isImage() Check if the modality is IMAGE
+ * @method bool isAudio() Check if the modality is AUDIO
+ * @method bool isVideo() Check if the modality is VIDEO
+ */
+class ModalityEnum extends AbstractEnum
+{
+    /**
+     * Text modality
+     */
+    public const TEXT = 'text';
+
+    /**
+     * Document modality (PDFs, Word docs, etc.)
+     */
+    public const DOCUMENT = 'document';
+
+    /**
+     * Image modality
+     */
+    public const IMAGE = 'image';
+
+    /**
+     * Audio modality
+     */
+    public const AUDIO = 'audio';
+
+    /**
+     * Video modality
+     */
+    public const VIDEO = 'video';
+}