@far-world-labs/verblets 0.1.1

package/src/json-schemas/schema-dot-org-photograph.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/schemas/photograph.json",
+  "type": "object",
+  "properties": {
+    "@context": {
+      "type": "string",
+      "pattern": "^http[s]?://schema.org$"
+    },
+    "@type": {
+      "type": "string",
+      "pattern": "^Photograph$"
+    },
+    "name": {
+      "type": "string"
+    },
+    "caption": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "keywords": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "thumbnail": {
+      "type": "object",
+      "properties": {
+        "@type": {
+          "type": "string",
+          "pattern": "^ImageObject$"
+        },
+        "url": {
+          "type": "string"
+        },
+        "width": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "height": {
+          "type": "integer",
+          "minimum": 1
+        }
+      },
+      "required": ["url"]
+    },
+    "image": {
+      "type": "object",
+      "properties": {
+        "@type": {
+          "type": "string",
+          "pattern": "^ImageObject$"
+        },
+        "url": {
+          "type": "string"
+        },
+        "width": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "height": {
+          "type": "integer",
+          "minimum": 1
+        }
+      },
+      "required": ["url"]
+    },
+    "contentLocation": {
+      "type": "object",
+      "properties": {
+        "@type": {
+          "type": "string",
+          "pattern": "^Place$"
+        },
+        "name": {
+          "type": "string"
+        },
+        "address": {
+          "type": "object",
+          "properties": {
+            "@type": {
+              "type": "string",
+              "pattern": "^PostalAddress$"
+            },
+            "streetAddress": {
+              "type": "string"
+            },
+            "addressLocality": {
+              "type": "string"
+            },
+            "addressRegion": {
+              "type": "string"
+            },
+            "postalCode": {
+              "type": "string"
+            },
+            "addressCountry": {
+              "type": "string"
+            }
+          },
+          "required": ["streetAddress", "addressLocality", "addressRegion", "postalCode", "addressCountry"]
+        },
+        "geo": {
+          "type": "object",
+          "properties": {
+            "@type": {
+              "type": "string",
+              "pattern": "^GeoCoordinates$"
+            },
+            "latitude": {
+              "type": "number"
+            },
+            "longitude": {
+              "type": "number"
+            }
+          },
+          "required": ["latitude", "longitude"]
+        }
+      },
+      "required": ["name"]
+    }
+  },
+  "required": ["@context", "@type", "name"]
+}

package/src/json-schemas/schema-dot-org-place.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "@type": {
+      "type": "string",
+      "enum": ["Place", "City"]
+    },
+    "name": {
+      "type": "string"
+    },
+    "address": {
+      "type": "object",
+      "properties": {
+        "@type": {
+          "type": "string",
+          "enum": ["PostalAddress"]
+        },
+        "streetAddress": {
+          "type": "string"
+        },
+        "addressLocality": {
+          "type": "string"
+        },
+        "addressRegion": {
+          "type": "string"
+        },
+        "postalCode": {
+          "type": "string"
+        },
+        "addressCountry": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": true
+    },
+    "geo": {
+      "type": "object",
+      "properties": {
+        "@type": {
+          "type": "string",
+          "enum": ["GeoCoordinates"]
+        },
+        "latitude": {
+          "type": "number"
+        },
+        "longitude": {
+          "type": "number"
+        }
+      },
+      "additionalProperties": true
+    }
+  },
+  "additionalProperties": true,
+  "required": ["@type", "name"]
+}

package/src/lib/any-signal/index.js

@@ -0,0 +1,28 @@
+/**
+ * Creates a new AbortSignal that is triggered when any of the given signals are aborted.
+ *
+ * @param {AbortSignal[]} signals - An array of AbortSignal instances to listen to.
+ * @returns {AbortSignal} - A new AbortSignal that is aborted when any of the input signals are aborted.
+ *
+ * @example
+ * const abortController1 = new AbortController();
+ * const abortController2 = new AbortController();
+ * const combinedSignal = anySignal([abortController1.signal, abortController2.signal]);
+ * fetch('https://example.com', { signal: combinedSignal });
+ * abortController1.abort(); // This will abort the fetch operation
+ */
+export default (signalsInitial) => {
+  const signals = signalsInitial.filter((s) => s);
+
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort();
+      break;
+    }
+    signal.addEventListener('abort', () => {
+      controller.abort();
+    });
+  }
+  return controller.signal;
+};

package/src/lib/chatgpt/index.js

@@ -0,0 +1,143 @@
+import fetch from 'node-fetch';
+
+import {
+  apiKey,
+  apiUrl,
+  debugPromptGlobally,
+  debugPromptGloballyIfChanged,
+  debugResultGlobally,
+  debugResultGloballyIfChanged,
+} from '../../constants/openai.js';
+import anySignal from '../any-signal/index.js';
+import {
+  get as getPromptResult,
+  set as setPromptResult,
+} from '../prompt-cache/index.js';
+import TimedAbortController from '../timed-abort-controller/index.js';
+import modelService from '../../services/llm-model/index.js';
+import { getClient as getRedis } from '../../services/redis/index.js';
+
+const shapeOutputDefault = (result) => {
+  // GPT-4
+  if (result.choices[0].message.tool_calls?.length) {
+    const toolCall = result.choices[0].message.tool_calls[0]
+    return {
+      name: toolCall['function'].name,
+      arguments: JSON.parse(
+	toolCall['function'].arguments
+      ),
+      result: result.choices[0].message.tool_calls[0].function
+    };
+  }
+  if (result.choices[0].message) {
+    return result.choices[0].message.content.trim();
+  }
+  return result.choices[0].text.trim();
+};
+
+const onBeforeRequestDefault = ({ debugPrompt, isCached, prompt }) => {
+  if (
+    debugPrompt ||
+    debugPromptGlobally ||
+    (debugPromptGloballyIfChanged && !isCached)
+  ) {
+    console.error(`+++ DEBUG PROMPT +++`);
+    console.error(prompt);
+    console.error('+++ DEBUG PROMPT END +++');
+  }
+};
+
+const onAfterRequestDefault = ({ debugResult, isCached, resultShaped }) => {
+  if (
+    debugResult ||
+      debugResultGlobally ||
+      (debugResultGloballyIfChanged && !isCached)
+  ) {
+    console.error(`+++ DEBUG RESULT +++`);
+    console.error(resultShaped);
+    console.error('+++ DEBUG RESULT END +++');
+  }
+};
+
+export const run = async (prompt, options = {}) => {
+  const {
+    abortSignal,
+    debugPrompt,
+    debugResult,
+    forceQuery,
+    modelOptions = {},
+    onAfterRequest = onAfterRequestDefault,
+    onBeforeRequest = onBeforeRequestDefault,
+    shapeOutput = shapeOutputDefault,
+  } = options;
+
+  debugger;
+
+  const modelFound = modelService.getModel(modelOptions.modelName);
+
+  const requestConfig = modelService.getRequestConfig({
+    prompt,
+    ...modelOptions,
+  });
+
+  const cache = await getRedis();
+  const { result: cacheResult } = await getPromptResult(cache, requestConfig);
+
+  onBeforeRequest({
+    isCached: !!cacheResult,
+    debugPrompt,
+    prompt,
+    requestConfig,
+  });
+
+  let result = cacheResult;
+  if (!cacheResult || forceQuery) {
+    const timeoutController = new TimedAbortController(
+      modelService.getModel(modelOptions.modelName).requestTimeout
+    );
+
+    // console.log(requestConfig, `${apiUrl}${modelFound.endpoint}`)
+
+    const response = await fetch(`${apiUrl}${modelFound.endpoint}`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestConfig),
+      signal: anySignal([abortSignal, timeoutController.signal]),
+    });
+
+    result = await response.json();
+
+    if (!response.ok) {
+      const vars = [
+        `status: ${response?.status}`,
+        `type: ${result?.error?.type}`,
+      ].join(', ');
+      throw new Error(
+        `Completions request [error]: ${result?.error?.message} (${vars})`
+      );
+    }
+
+    timeoutController.clearTimeout();
+
+    await setPromptResult(cache, requestConfig, result);
+  }
+
+  debugger;
+  const resultShaped = shapeOutput(result);
+
+  onAfterRequest({
+    debugResult,
+    isCached: !!cacheResult,
+    prompt,
+    requestConfig,
+    result,
+    resultShaped,
+  });
+
+  return resultShaped;
+};
+
+export default run;

package/src/lib/editor/index.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+export default async () => {
+  // Create a temporary file for editing
+  const tempFile = path.join(os.tmpdir(), 'verblets_editor.txt');
+  await fs.writeFile(tempFile, '');
+
+  // Determine the editor to use (use 'nano' as the default editor)
+  const editor = process.env.EDITOR || 'nano';
+
+  // Spawn the editor process
+  const editorProcess = spawn(editor, [tempFile], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  return new Promise((resolve) => {
+    // Listen for the editor process exit event
+    editorProcess.on('exit', async () => {
+      // Read the content of the temporary file and echo it
+      const content = await fs.readFile(tempFile, 'utf-8');
+      resolve(content);
+
+      // Clean up the temporary file
+      await fs.unlink(tempFile);
+    });
+  });
+};