create-prisma-php-app 4.0.0-alpha.2 → 4.0.0-alpha.21

package/dist/settings/restart-websocket.ts

@@ -1,46 +1,52 @@
-import { spawn, ChildProcess } from "child_process";
 import { join } from "path";
-import chokidar from "chokidar";
-import { getFileMeta } from "./utils.js";
-
-const { __dirname } = getFileMeta();
-
-const phpPath = "php";
-const serverScriptPath = join(__dirname, "..", "websocket-server.php");
-
-let serverProcess: ChildProcess | null = null;
-
-const restartServer = (): void => {
-  if (serverProcess) {
-    console.log("Stopping WebSocket server...");
-    serverProcess.kill("SIGINT");
-    serverProcess = null;
-  }
-
-  console.log("Starting WebSocket server...");
-  serverProcess = spawn(phpPath, [serverScriptPath]);
-
-  serverProcess.stdout?.on("data", (data: Buffer) => {
-    console.log(`WebSocket Server: ${data.toString()}`);
-  });
-
-  serverProcess.stderr?.on("data", (data: Buffer) => {
-    console.error(`WebSocket Server Error: ${data.toString()}`);
-  });
-
-  serverProcess.on("close", (code: number) => {
-    console.log(`WebSocket server exited with code ${code}`);
-  });
-};
-
-// Initial start
-restartServer();
-
-// Watch for changes
-chokidar
-  .watch(join(__dirname, "..", "src", "Websocket", "**", "*"))
-  .on("change", (path: string) => {
-    const fileChanged = path.split("\\").pop();
-    console.log(`File changed: src/Websocket/${fileChanged}`);
-    restartServer();
-  });
+import {
+  createRestartableProcess,
+  createSrcWatcher,
+  DebouncedWorker,
+  DEFAULT_AWF,
+  onExit,
+} from "./utils.js";
+
+// Config
+const phpPath = process.env.PHP_PATH ?? "php";
+const SRC_DIR = join(process.cwd(), "src");
+const serverScriptPath = join(
+  SRC_DIR,
+  "Lib",
+  "Websocket",
+  "websocket-server.php"
+);
+
+// Restartable WS server
+const ws = createRestartableProcess({
+  name: "WebSocket",
+  cmd: phpPath,
+  args: [serverScriptPath],
+  windowsKillTree: true,
+});
+
+ws.start();
+
+// Debounced restarter
+const restarter = new DebouncedWorker(
+  async () => {
+    await ws.restart("file change");
+  },
+  400,
+  "ws-restart"
+);
+
+// Watch ./src recursively; restart on code/data file changes
+createSrcWatcher(SRC_DIR, {
+  exts: [".php", ".ts", ".js", ".json"],
+  onEvent: (ev, _abs, rel) => restarter.schedule(`${ev}: ${rel}`),
+  awaitWriteFinish: DEFAULT_AWF,
+  logPrefix: "WS watch",
+  usePolling: true,
+  interval: 1000,
+});
+
+// Graceful shutdown
+onExit(async () => {
+  await ws.stop();
+});

package/dist/settings/utils.ts

@@ -1,5 +1,8 @@
 import { fileURLToPath } from "url";
 import { dirname } from "path";
+import chokidar, { FSWatcher } from "chokidar";
+import { spawn, ChildProcess, execFile } from "child_process";
+import { relative } from "path";
 
 /**
  * Retrieves the file metadata including the filename and directory name.
@@ -12,3 +15,240 @@ export function getFileMeta() {
   const __dirname = dirname(__filename);
   return { __filename, __dirname };
 }
+
+export type WatchEvent = "add" | "addDir" | "change" | "unlink" | "unlinkDir";
+
+export const DEFAULT_IGNORES: (string | RegExp)[] = [
+  /(^|[\/\\])\../, // dotfiles
+  "**/node_modules/**",
+  "**/vendor/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.cache/**",
+  "**/*.log",
+  "**/*.tmp",
+  "**/*.swp",
+];
+
+export const DEFAULT_AWF = { stabilityThreshold: 300, pollInterval: 100 };
+
+/**
+ * Create a chokidar watcher for a given root. Optionally filter by file extensions.
+ */
+export function createSrcWatcher(
+  root: string,
+  opts: {
+    exts?: string[]; // e.g. ['.php','.ts']
+    onEvent: (event: WatchEvent, absPath: string, relPath: string) => void;
+    ignored?: (string | RegExp)[];
+    awaitWriteFinish?: { stabilityThreshold: number; pollInterval: number };
+    logPrefix?: string;
+    usePolling?: boolean;
+    interval?: number;
+  }
+): FSWatcher {
+  const {
+    exts,
+    onEvent,
+    ignored = DEFAULT_IGNORES,
+    awaitWriteFinish = DEFAULT_AWF,
+    logPrefix = "watch",
+    usePolling = true,
+  } = opts;
+
+  const watcher = chokidar.watch(root, {
+    ignoreInitial: true,
+    persistent: true,
+    ignored,
+    awaitWriteFinish,
+    usePolling,
+    interval: opts.interval ?? 1000,
+  });
+
+  watcher
+    .on("ready", () => {
+      console.log(`[${logPrefix}] Watching ${root.replace(/\\/g, "/")}/**/*`);
+    })
+    .on("all", (event: WatchEvent, filePath: string) => {
+      // Optional extension filter
+      if (exts && exts.length > 0) {
+        const ok = exts.some((ext) => filePath.endsWith(ext));
+        if (!ok) return;
+      }
+      const rel = relative(root, filePath).replace(/\\/g, "/");
+      if (event === "add" || event === "change" || event === "unlink") {
+        onEvent(event, filePath, rel);
+      }
+    })
+    .on("error", (err) => console.error(`[${logPrefix}] Error:`, err));
+
+  return watcher;
+}
+
+/**
+ * Debounced worker that ensures only one run at a time; extra runs get queued once.
+ */
+export class DebouncedWorker {
+  private timer: NodeJS.Timeout | null = null;
+  private running = false;
+  private queued = false;
+
+  constructor(
+    private work: () => Promise<void> | void,
+    private debounceMs = 350,
+    private name = "worker"
+  ) {}
+
+  schedule(reason?: string) {
+    if (reason) console.log(`[${this.name}] ${reason} → scheduled`);
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.runNow().catch(() => {});
+    }, this.debounceMs);
+  }
+
+  private async runNow() {
+    if (this.running) {
+      this.queued = true;
+      return;
+    }
+    this.running = true;
+    try {
+      await this.work();
+    } catch (err) {
+      console.error(`[${this.name}] error:`, err);
+    } finally {
+      this.running = false;
+      if (this.queued) {
+        this.queued = false;
+        this.runNow().catch(() => {});
+      }
+    }
+  }
+}
+
+/**
+ * Cross-platform restartable process.
+ */
+export function createRestartableProcess(spec: {
+  name: string;
+  cmd: string;
+  args?: string[];
+  stdio?: "inherit" | [any, any, any];
+  gracefulSignal?: NodeJS.Signals;
+  forceKillAfterMs?: number;
+  windowsKillTree?: boolean;
+  onStdout?: (buf: Buffer) => void;
+  onStderr?: (buf: Buffer) => void;
+}) {
+  const {
+    name,
+    cmd,
+    args = [],
+    stdio = ["ignore", "pipe", "pipe"],
+    gracefulSignal = "SIGINT",
+    forceKillAfterMs = 2000,
+    windowsKillTree = true,
+    onStdout,
+    onStderr,
+  } = spec;
+
+  let child: ChildProcess | null = null;
+
+  function start() {
+    console.log(`[${name}] Starting: ${cmd} ${args.join(" ")}`.trim());
+    child = spawn(cmd, args, { stdio, windowsHide: true });
+
+    child.stdout?.on("data", (buf: Buffer) => {
+      if (onStdout) onStdout(buf);
+      else process.stdout.write(`[${name}] ${buf.toString()}`);
+    });
+
+    child.stderr?.on("data", (buf: Buffer) => {
+      if (onStderr) onStderr(buf);
+      else process.stderr.write(`[${name}:err] ${buf.toString()}`);
+    });
+
+    child.on("close", (code) => {
+      console.log(`[${name}] Exited with code ${code}`);
+    });
+
+    child.on("error", (err) => {
+      console.error(`[${name}] Failed to start:`, err);
+    });
+
+    return child;
+  }
+
+  function killOnWindows(pid: number): Promise<void> {
+    return new Promise((resolve) => {
+      const cp = execFile("taskkill", ["/F", "/T", "/PID", String(pid)], () =>
+        resolve()
+      );
+      cp.on("error", () => resolve());
+    });
+  }
+
+  async function stop(): Promise<void> {
+    if (!child || child.killed) return;
+    const pid = child.pid!;
+    console.log(`[${name}] Stopping…`);
+
+    if (process.platform === "win32" && windowsKillTree) {
+      await killOnWindows(pid);
+      child = null;
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      const done = () => resolve();
+      child!.once("close", done).once("exit", done).once("disconnect", done);
+      try {
+        child!.kill(gracefulSignal);
+      } catch {
+        resolve();
+      }
+      setTimeout(() => {
+        if (child && !child.killed) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {}
+        }
+      }, forceKillAfterMs);
+    });
+    child = null;
+  }
+
+  async function restart(reason?: string) {
+    if (reason) console.log(`[${name}] Restart requested: ${reason}`);
+    await stop();
+    return start();
+  }
+
+  function getChild() {
+    return child;
+  }
+
+  return { start, stop, restart, getChild };
+}
+
+/**
+ * Register shutdown cleanup callbacks.
+ */
+export function onExit(fn: () => Promise<void> | void) {
+  const wrap = (sig: string) => async () => {
+    console.log(`[proc] Received ${sig}, shutting down…`);
+    try {
+      await fn();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", wrap("SIGINT"));
+  process.on("SIGTERM", wrap("SIGTERM"));
+  process.on("uncaughtException", async (err) => {
+    console.error("[proc] Uncaught exception:", err);
+    await wrap("uncaughtException")();
+  });
+}

package/dist/src/Lib/AI/ChatGPTClient.php

@@ -0,0 +1,147 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\AI;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Exception\RequestException;
+use Lib\Validator;
+use RuntimeException;
+
+class ChatGPTClient
+{
+    private Client $client;
+    private string $apiUrl = '';
+    private string $apiKey = '';
+    private array $cache = [];
+
+    public function __construct(?Client $client = null)
+    {
+        // Initialize the Guzzle HTTP client, allowing for dependency injection
+        $this->client = $client ?: new Client();
+
+        // API URL for chat completions
+        $this->apiUrl = 'https://api.openai.com/v1/chat/completions';
+
+        // Get the API key from environment variables (keep this private and secure)
+        $this->apiKey = $_ENV['CHATGPT_API_KEY'];
+    }
+
+    /**
+     * Determines the appropriate model based on internal logic.
+     *
+     * @param array $conversationHistory The conversation history array.
+     * @return string The model name to be used.
+     */
+    protected function determineModel(array $conversationHistory): string
+    {
+        $messageCount = count($conversationHistory);
+        $totalTokens = array_reduce(
+            $conversationHistory,
+            fn($carry, $item) => $carry + str_word_count($item['content'] ?? ''),
+            0
+        );
+
+        // If the conversation is long or complex, use a model with more tokens
+        if ($totalTokens > 4000 || $messageCount > 10) {
+            return 'gpt-3.5-turbo-16k'; // Use the model with a larger token limit
+        }
+
+        // Default to the standard model for shorter conversations
+        return 'gpt-3.5-turbo';
+    }
+
+    /**
+     * Formats the conversation history to ensure it is valid.
+     *
+     * @param array $conversationHistory The conversation history array.
+     * @return array The formatted conversation history.
+     */
+    protected function formatConversationHistory(array $conversationHistory): array
+    {
+        $formattedHistory = [];
+        foreach ($conversationHistory as $message) {
+            if (is_array($message) && isset($message['role'], $message['content']) && Validator::string($message['content'])) {
+                $formattedHistory[] = $message;
+            } else {
+                $formattedHistory[] = ['role' => 'user', 'content' => (string) $message];
+            }
+        }
+        return $formattedHistory;
+    }
+
+    /**
+     * Sends a message to the OpenAI API and returns the AI's response as HTML.
+     *
+     * @param array  $conversationHistory The conversation history array containing previous messages.
+     * @param string $userMessage         The new user message to add to the conversation.
+     * @return string The AI-generated HTML response.
+     *
+     * @throws \InvalidArgumentException If a message in the conversation history is not valid.
+     * @throws RuntimeException         If the API request fails or returns an unexpected format.
+     */
+    public function sendMessage(array $conversationHistory, string $userMessage): string
+    {
+        if (!Validator::string($userMessage)) {
+            throw new \InvalidArgumentException("Invalid user message: must be a string.");
+        }
+
+        // Optional: Convert emojis or special patterns in the message
+        $userMessage = Validator::emojis($userMessage);
+
+        // Prepare the conversation, including a system-level instruction to return valid HTML
+        $systemInstruction = [
+            'role'    => 'system',
+            'content' => 'You are ChatGPT. Please provide your response in valid HTML format.'
+        ];
+
+        // Format existing history, then prepend the system message
+        $formattedHistory = $this->formatConversationHistory($conversationHistory);
+        array_unshift($formattedHistory, $systemInstruction);
+
+        // Append the new user message
+        $formattedHistory[] = ['role' => 'user', 'content' => $userMessage];
+
+        // Check cache
+        $cacheKey = md5(serialize($formattedHistory));
+        if (isset($this->cache[$cacheKey])) {
+            return $this->cache[$cacheKey];
+        }
+
+        // Determine the appropriate model to use
+        $model = $this->determineModel($formattedHistory);
+
+        try {
+            // Sending a POST request to the AI API
+            $response = $this->client->request('POST', $this->apiUrl, [
+                'headers' => [
+                    'Authorization' => 'Bearer ' . $this->apiKey,
+                    'Content-Type'  => 'application/json',
+                ],
+                'json' => [
+                    'model'       => $model,
+                    'messages'    => $formattedHistory,
+                    'max_tokens'  => 500,
+                ],
+            ]);
+
+            $responseBody    = $response->getBody();
+            $responseContent = json_decode((string) $responseBody, true);
+
+            // Check if response is in expected format
+            if (isset($responseContent['choices'][0]['message']['content'])) {
+                $aiMessage = $responseContent['choices'][0]['message']['content'];
+
+                // Cache the result
+                $this->cache[$cacheKey] = $aiMessage;
+
+                return $aiMessage;
+            }
+
+            throw new RuntimeException('Unexpected API response format.');
+        } catch (RequestException $e) {
+            throw new RuntimeException("API request failed: " . $e->getMessage(), 0, $e);
+        }
+    }
+}