@superdangerous/app-framework 4.9.0

package/src/services/conversationStorage.ts

@@ -0,0 +1,232 @@
+/**
+ * Conversation Storage Service
+ * Provides persistent storage for AI conversations using lowdb
+ */
+
+import { Low } from "lowdb";
+import { JSONFile } from "lowdb/node";
+import path from "path";
+import { ensureDir } from "fs-extra";
+import { createLogger } from "../core/index.js";
+let logger: any; // Will be initialized when needed
+
+function ensureLogger() {
+  if (!logger) {
+    logger = createLogger("ConversationStorage");
+  }
+  return logger;
+}
+
+interface Message {
+  role: "user" | "assistant" | "system";
+  content: string;
+  timestamp?: string;
+}
+
+interface Conversation {
+  id: string;
+  title?: string;
+  messages: Message[];
+  metadata?: Record<string, any>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface ConversationsDB {
+  conversations: Record<string, Conversation>;
+}
+
+const defaultData: ConversationsDB = {
+  conversations: {},
+};
+
+class ConversationStorage {
+  private db: Low<ConversationsDB> | null = null;
+  private initialized: boolean = false;
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    try {
+      // Ensure data directory exists
+      const dataDir = path.join(process.cwd(), "data");
+      await ensureDir(dataDir);
+
+      // Initialize lowdb with JSON file adapter
+      const dbPath = path.join(dataDir, "conversations.json");
+      const adapter = new JSONFile<ConversationsDB>(dbPath);
+      this.db = new Low<ConversationsDB>(adapter, defaultData);
+
+      // Read data from file
+      await this.db.read();
+
+      // Initialize with default data if file doesn't exist
+      if (!this.db.data) {
+        this.db.data = defaultData;
+        await this.db.write();
+      }
+
+      // Ensure conversations object exists
+      if (!this.db.data.conversations) {
+        this.db.data.conversations = {};
+        await this.db.write();
+      }
+
+      this.initialized = true;
+      ensureLogger().info("Conversation storage initialized");
+    } catch (_error) {
+      ensureLogger().error(
+        "Failed to initialize conversation storage:",
+        _error,
+      );
+      throw _error;
+    }
+  }
+
+  async getConversation(conversationId: string): Promise<Conversation | null> {
+    await this.initialize();
+    return this.db!.data!.conversations[conversationId] || null;
+  }
+
+  async saveConversation(
+    conversationId: string,
+    conversation: Partial<Conversation>,
+  ): Promise<Conversation> {
+    await this.initialize();
+
+    const now = new Date().toISOString();
+    const existing = this.db!.data!.conversations[conversationId];
+    const fullConversation: Conversation = {
+      ...existing,
+      ...conversation,
+      id: conversationId,
+      messages: conversation.messages ?? existing?.messages ?? [],
+      createdAt: existing?.createdAt ?? conversation.createdAt ?? now,
+      updatedAt: now,
+    };
+
+    this.db!.data!.conversations[conversationId] = fullConversation;
+    await this.db!.write();
+
+    ensureLogger().debug(`Saved conversation: ${conversationId}`);
+    return fullConversation;
+  }
+
+  async deleteConversation(conversationId: string): Promise<boolean> {
+    await this.initialize();
+
+    if (this.db!.data!.conversations[conversationId]) {
+      delete this.db!.data!.conversations[conversationId];
+      await this.db!.write();
+      ensureLogger().debug(`Deleted conversation: ${conversationId}`);
+      return true;
+    }
+
+    return false;
+  }
+
+  async getAllConversations(): Promise<Conversation[]> {
+    await this.initialize();
+    return Object.values(this.db!.data!.conversations);
+  }
+
+  async getRecentConversations(limit: number = 10): Promise<Conversation[]> {
+    await this.initialize();
+    const conversations = Object.values(this.db!.data!.conversations);
+
+    return conversations
+      .sort(
+        (a, b) =>
+          new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
+      )
+      .slice(0, limit);
+  }
+
+  async addMessage(
+    conversationId: string,
+    message: Message,
+  ): Promise<Conversation> {
+    await this.initialize();
+
+    let conversation = this.db!.data!.conversations[conversationId];
+
+    if (!conversation) {
+      conversation = {
+        id: conversationId,
+        messages: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+    }
+
+    message.timestamp = message.timestamp || new Date().toISOString();
+    conversation.messages.push(message);
+    conversation.updatedAt = new Date().toISOString();
+
+    this.db!.data!.conversations[conversationId] = conversation;
+    await this.db!.write();
+
+    return conversation;
+  }
+
+  async clearAllConversations(): Promise<void> {
+    await this.initialize();
+    this.db!.data!.conversations = {};
+    await this.db!.write();
+    ensureLogger().info("Cleared all conversations");
+  }
+
+  async exportConversations(): Promise<ConversationsDB> {
+    await this.initialize();
+    return { ...this.db!.data! };
+  }
+
+  async importConversations(data: ConversationsDB): Promise<void> {
+    await this.initialize();
+    this.db!.data = data;
+    await this.db!.write();
+    ensureLogger().info("Imported conversations");
+  }
+
+  async getConversationStats(): Promise<Record<string, any>> {
+    await this.initialize();
+    const conversations = Object.values(this.db!.data!.conversations);
+
+    return {
+      total: conversations.length,
+      totalMessages: conversations.reduce(
+        (sum, c) => sum + c.messages.length,
+        0,
+      ),
+      averageLength:
+        conversations.length > 0
+          ? conversations.reduce((sum, c) => sum + c.messages.length, 0) /
+            conversations.length
+          : 0,
+      oldestConversation:
+        conversations.length > 0
+          ? conversations.reduce((oldest, c) =>
+              new Date(c.createdAt) < new Date(oldest.createdAt) ? c : oldest,
+            ).createdAt
+          : null,
+      newestConversation:
+        conversations.length > 0
+          ? conversations.reduce((newest, c) =>
+              new Date(c.createdAt) > new Date(newest.createdAt) ? c : newest,
+            ).createdAt
+          : null,
+    };
+  }
+}
+
+// Singleton instance
+let conversationStorage: ConversationStorage | null = null;
+
+export function getConversationStorage(): ConversationStorage {
+  if (!conversationStorage) {
+    conversationStorage = new ConversationStorage();
+  }
+  return conversationStorage;
+}
+
+export default ConversationStorage;

package/src/services/crossPlatformBuffer.ts

@@ -0,0 +1,341 @@
+/**
+ * Cross-Platform Buffer Handling Module
+ *
+ * Ensures consistent data representation across ARM and x86 architectures
+ * by using explicit buffer operations that are not affected by processor endianness.
+ */
+
+export type Endianness = "LE" | "BE";
+export type DataType =
+  | "uint16"
+  | "int16"
+  | "uint32"
+  | "int32"
+  | "float32"
+  | "float64"
+  | "bool";
+
+export interface BufferOptions {
+  endian?: Endianness;
+  wordSwap?: boolean;
+  byteSwap?: boolean;
+}
+
+export class CrossPlatformBuffer {
+  private systemEndianness: Endianness;
+
+  constructor() {
+    // Detect system endianness for debugging/logging purposes
+    this.systemEndianness = this.detectSystemEndianness();
+  }
+
+  /**
+   * Detect system endianness (for logging/debugging only)
+   */
+  private detectSystemEndianness(): Endianness {
+    const arrayBuffer = new ArrayBuffer(2);
+    const uint8Array = new Uint8Array(arrayBuffer);
+    const uint16Array = new Uint16Array(arrayBuffer);
+
+    uint16Array[0] = 0x1234;
+
+    if (uint8Array[0] === 0x12) {
+      return "BE"; // Big Endian
+    } else {
+      return "LE"; // Little Endian
+    }
+  }
+
+  /**
+   * Get system endianness
+   */
+  getSystemEndianness(): Endianness {
+    return this.systemEndianness;
+  }
+
+  /**
+   * Convert float32 to two 16-bit registers with explicit endianness control
+   */
+  float32ToRegisters(
+    value: number,
+    endian: Endianness = "LE",
+    wordSwap: boolean = false,
+    byteSwap: boolean = false,
+  ): [number, number] {
+    // Create a buffer to hold the float32
+    const buffer = new ArrayBuffer(4);
+    const float32View = new Float32Array(buffer);
+    const dataView = new DataView(buffer);
+
+    // Write the float32 value
+    float32View[0] = value;
+
+    // Read as two 16-bit values with specified endianness
+    let reg1: number, reg2: number;
+
+    if (endian === "BE") {
+      // Big Endian: most significant word first
+      reg1 = dataView.getUint16(0, false); // Big endian read
+      reg2 = dataView.getUint16(2, false);
+    } else {
+      // Little Endian: least significant word first
+      reg1 = dataView.getUint16(0, true); // Little endian read
+      reg2 = dataView.getUint16(2, true);
+    }
+
+    // Apply word swap if needed
+    if (wordSwap) {
+      [reg1, reg2] = [reg2, reg1];
+    }
+
+    // Apply byte swap within each word if needed
+    if (byteSwap) {
+      reg1 = ((reg1 & 0xff) << 8) | ((reg1 >> 8) & 0xff);
+      reg2 = ((reg2 & 0xff) << 8) | ((reg2 >> 8) & 0xff);
+    }
+
+    return [reg1, reg2];
+  }
+
+  /**
+   * Convert two 16-bit registers to float32 with explicit endianness control
+   */
+  registersToFloat32(
+    reg1: number,
+    reg2: number,
+    endian: Endianness = "LE",
+    wordSwap: boolean = false,
+    byteSwap: boolean = false,
+  ): number {
+    // Apply byte swap within each word if needed
+    if (byteSwap) {
+      reg1 = ((reg1 & 0xff) << 8) | ((reg1 >> 8) & 0xff);
+      reg2 = ((reg2 & 0xff) << 8) | ((reg2 >> 8) & 0xff);
+    }
+
+    // Apply word swap if needed
+    if (wordSwap) {
+      [reg1, reg2] = [reg2, reg1];
+    }
+
+    // Create a buffer and write the registers
+    const buffer = new ArrayBuffer(4);
+    const dataView = new DataView(buffer);
+
+    if (endian === "BE") {
+      // Big Endian: write as big endian
+      dataView.setUint16(0, reg1, false);
+      dataView.setUint16(2, reg2, false);
+    } else {
+      // Little Endian: write as little endian
+      dataView.setUint16(0, reg1, true);
+      dataView.setUint16(2, reg2, true);
+    }
+
+    // Read as float32
+    const float32View = new Float32Array(buffer);
+    return float32View[0];
+  }
+
+  /**
+   * Convert int32 to two 16-bit registers
+   */
+  int32ToRegisters(
+    value: number,
+    endian: Endianness = "LE",
+    wordSwap: boolean = false,
+  ): [number, number] {
+    const buffer = new ArrayBuffer(4);
+    const dataView = new DataView(buffer);
+
+    // Write the int32 value
+    dataView.setInt32(0, value, endian === "LE");
+
+    // Read as two 16-bit values
+    let reg1 = dataView.getUint16(0, endian === "LE");
+    let reg2 = dataView.getUint16(2, endian === "LE");
+
+    if (wordSwap) {
+      [reg1, reg2] = [reg2, reg1];
+    }
+
+    return [reg1, reg2];
+  }
+
+  /**
+   * Convert two 16-bit registers to int32
+   */
+  registersToInt32(
+    reg1: number,
+    reg2: number,
+    endian: Endianness = "LE",
+    wordSwap: boolean = false,
+  ): number {
+    if (wordSwap) {
+      [reg1, reg2] = [reg2, reg1];
+    }
+
+    const buffer = new ArrayBuffer(4);
+    const dataView = new DataView(buffer);
+
+    dataView.setUint16(0, reg1, endian === "LE");
+    dataView.setUint16(2, reg2, endian === "LE");
+
+    return dataView.getInt32(0, endian === "LE");
+  }
+
+  /**
+   * Convert uint32 to two 16-bit registers
+   */
+  uint32ToRegisters(
+    value: number,
+    endian: Endianness = "LE",
+    wordSwap: boolean = false,
+  ): [number, number] {
+    const buffer = new ArrayBuffer(4);
+    const dataView = new DataView(buffer);
+
+    // Write the uint32 value
+    dataView.setUint32(0, value, endian === "LE");
+
+    // Read as two 16-bit values
+    let reg1 = dataView.getUint16(0, endian === "LE");
+    let reg2 = dataView.getUint16(2, endian === "LE");
+
+    if (wordSwap) {
+      [reg1, reg2] = [reg2, reg1];
+    }
+
+    return [reg1, reg2];
+  }
+
+  /**
+   * Convert two 16-bit registers to uint32
+   */
+  registersToUint32(
+    reg1: number,
+    reg2: number,
+    endian: Endianness = "LE",
+    wordSwap: boolean = false,
+  ): number {
+    if (wordSwap) {
+      [reg1, reg2] = [reg2, reg1];
+    }
+
+    const buffer = new ArrayBuffer(4);
+    const dataView = new DataView(buffer);
+
+    dataView.setUint16(0, reg1, endian === "LE");
+    dataView.setUint16(2, reg2, endian === "LE");
+
+    return dataView.getUint32(0, endian === "LE");
+  }
+
+  /**
+   * Convert boolean to register value
+   */
+  boolToRegister(value: boolean): number {
+    return value ? 1 : 0;
+  }
+
+  /**
+   * Convert register value to boolean
+   */
+  registerToBool(value: number): boolean {
+    return value !== 0;
+  }
+
+  /**
+   * Convert int16 to register with proper sign extension
+   */
+  int16ToRegister(value: number): number {
+    // Ensure value is within int16 range
+    value = Math.max(-32768, Math.min(32767, value));
+
+    // Convert to unsigned representation
+    if (value < 0) {
+      return 0x10000 + value; // Two's complement
+    }
+    return value;
+  }
+
+  /**
+   * Convert register to int16 with proper sign handling
+   */
+  registerToInt16(value: number): number {
+    // Check if the sign bit is set
+    if (value & 0x8000) {
+      // Negative number in two's complement
+      return value - 0x10000;
+    }
+    return value;
+  }
+
+  /**
+   * Convert string to register array
+   */
+  stringToRegisters(str: string, maxLength: number = 32): number[] {
+    const registers: number[] = [];
+    const buffer = Buffer.from(str, "utf8");
+
+    // Pad with zeros to ensure even number of bytes
+    const paddedLength = Math.min(maxLength, Math.ceil(buffer.length / 2) * 2);
+
+    for (let i = 0; i < paddedLength; i += 2) {
+      const byte1 = buffer[i] || 0;
+      const byte2 = buffer[i + 1] || 0;
+      registers.push((byte1 << 8) | byte2);
+    }
+
+    return registers;
+  }
+
+  /**
+   * Convert register array to string
+   */
+  registersToString(registers: number[]): string {
+    const bytes: number[] = [];
+
+    for (const reg of registers) {
+      bytes.push((reg >> 8) & 0xff); // High byte
+      bytes.push(reg & 0xff); // Low byte
+    }
+
+    // Remove trailing zeros
+    while (bytes.length > 0 && bytes[bytes.length - 1] === 0) {
+      bytes.pop();
+    }
+
+    return Buffer.from(bytes).toString("utf8");
+  }
+
+  /**
+   * Validate register value is within 16-bit range
+   */
+  validateRegisterValue(value: number): boolean {
+    return Number.isInteger(value) && value >= 0 && value <= 0xffff;
+  }
+
+  /**
+   * Create a buffer configuration for consistent handling
+   */
+  createBufferConfig(options: BufferOptions = {}): Required<BufferOptions> {
+    return {
+      endian: options.endian || "LE",
+      wordSwap: options.wordSwap || false,
+      byteSwap: options.byteSwap || false,
+    };
+  }
+}
+
+// Singleton instance
+let crossPlatformBuffer: CrossPlatformBuffer | null = null;
+
+export function getCrossPlatformBuffer(): CrossPlatformBuffer {
+  if (!crossPlatformBuffer) {
+    crossPlatformBuffer = new CrossPlatformBuffer();
+  }
+  return crossPlatformBuffer;
+}
+
+export default CrossPlatformBuffer;

package/src/services/index.ts

@@ -0,0 +1,47 @@
+/**
+ * Services Module Exports
+ */
+
+// Configuration management - use SettingsService
+
+// Other services
+export { getConversationStorage } from "./conversationStorage.js";
+export { CrossPlatformBuffer } from "./crossPlatformBuffer.js";
+export { getNetworkService } from "./networkService.js";
+export { getUpdateService } from "./updateService.js";
+export {
+  createWebSocketServer,
+  getWebSocketServer,
+} from "./websocketServer.js";
+export {
+  SettingsService,
+  CommonSettingsCategories,
+} from "./settingsService.js";
+export type {
+  SettingsCategory,
+  SettingsField,
+  SettingsOptions,
+} from "./settingsService.js";
+
+// WebSocket events
+export {
+  WebSocketEventManager,
+  TypedEventEmitter,
+  EventTypes,
+  EventPatterns,
+} from "./websocketEvents.js";
+export type { EventPayload, EventResponse } from "./websocketEvents.js";
+
+// AI Service
+export { aiService, AIService } from "./aiService.js";
+export type {
+  AIConfig,
+  AIMessage,
+  AIResponse,
+  AIAnalysisOptions,
+  AIProvider,
+} from "./aiService.js";
+
+// Queue Service
+export { default as QueueService } from "./queueService.js";
+export type { QueueJob, QueueConfig, JobHandler } from "./queueService.js";