@sylphx/flow 1.0.1 → 1.0.3

package/src/utils/models-dev.ts

@@ -0,0 +1,91 @@
+/**
+ * Models.dev API Integration
+ * Fetch model metadata as fallback source
+ */
+
+export interface ModelMetadata {
+  id: string;
+  name?: string;
+  contextLength?: number;
+  maxOutput?: number;
+  inputPrice?: number;
+  outputPrice?: number;
+  provider?: string;
+  description?: string;
+}
+
+interface ModelsDevResponse {
+  models: Array<{
+    id: string;
+    name?: string;
+    context_length?: number;
+    max_output?: number;
+    pricing?: {
+      input?: number;
+      output?: number;
+    };
+    provider?: string;
+    description?: string;
+  }>;
+}
+
+let cachedModels: Map<string, ModelMetadata> | null = null;
+
+/**
+ * Fetch model metadata from models.dev
+ */
+export async function fetchModelsMetadata(): Promise<Map<string, ModelMetadata>> {
+  if (cachedModels) {
+    return cachedModels;
+  }
+
+  try {
+    const response = await fetch('https://models.dev/api.json', {
+      headers: {
+        'User-Agent': 'sylphx-flow/1.0',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch models.dev: ${response.status}`);
+    }
+
+    const data = (await response.json()) as ModelsDevResponse;
+
+    const models = new Map<string, ModelMetadata>();
+
+    for (const model of data.models) {
+      models.set(model.id, {
+        id: model.id,
+        name: model.name,
+        contextLength: model.context_length,
+        maxOutput: model.max_output,
+        inputPrice: model.pricing?.input,
+        outputPrice: model.pricing?.output,
+        provider: model.provider,
+        description: model.description,
+      });
+    }
+
+    cachedModels = models;
+    return models;
+  } catch (error) {
+    console.error('Failed to fetch models.dev:', error);
+    return new Map();
+  }
+}
+
+/**
+ * Get metadata for a specific model
+ */
+export async function getModelMetadata(modelId: string): Promise<ModelMetadata | null> {
+  const models = await fetchModelsMetadata();
+  return models.get(modelId) || null;
+}
+
+/**
+ * Clear cache (for testing or forcing refresh)
+ */
+export function clearModelsCache(): void {
+  cachedModels = null;
+}

package/src/utils/notifications.ts

@@ -0,0 +1,169 @@
+/**
+ * Notification System
+ * Provides terminal and OS-level notifications for AI responses
+ */
+
+import { playNotificationSound } from './audio-player.js';
+
+// Terminal notification with sound
+export function sendTerminalNotification(title: string, message: string, options?: {
+  sound?: boolean;
+  duration?: number;
+}) {
+  const { sound = true, duration = 3000 } = options || {};
+
+  // Play system sound using cross-platform audio player
+  if (sound) {
+    playNotificationSound().catch((error) => {
+      // Fail silently - don't crash on sound errors
+      if (process.env.DEBUG) {
+        console.error('[Notifications] Failed to play sound:', error);
+      }
+    });
+  }
+
+  // Terminal bell only (no visual output to avoid interfering with Ink UI)
+  console.log('\u0007'); // Bell character
+
+  // Visual notification removed - interferes with Ink UI
+  // Terminal notifications in TUI apps should use Ink components instead
+}
+
+// OS-level notification using system APIs
+export async function sendOSNotification(title: string, message: string, options?: {
+  icon?: string;
+  urgency?: 'low' | 'normal' | 'critical';
+  sound?: boolean;
+  timeout?: number;
+}) {
+  const {
+    icon = '🌀', // Flow-themed spiral emoji for Sylphx Flow notifications
+    urgency = 'normal',
+    sound = true,
+    timeout = 5000
+  } = options || {};
+  
+  try {
+    if (process.platform === 'darwin') {
+      // macOS: use osascript with simplified approach
+      const { spawn } = require('child_process');
+      
+      await new Promise<void>((resolve, reject) => {
+        // Simple notification without complex escaping
+        const args = [
+          '-e', `display notification "${message.replace(/"/g, '\\"')}" with title "${title.replace(/"/g, '\\"')}"`
+        ];
+        
+        const proc = spawn('osascript', args, { 
+          stdio: 'pipe',
+          env: { ...process.env, PATH: '/usr/bin:/bin:/usr/sbin:/sbin' }
+        });
+        
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+          stderr += data.toString();
+        });
+        
+        proc.on('exit', (code) => {
+          if (code === 0) {
+            // Play sound separately if needed using cross-platform audio player
+            if (sound) {
+              playNotificationSound().catch(() => {
+                // Ignore sound errors
+              });
+            }
+            resolve();
+          } else {
+            reject(new Error(`osascript failed with code ${code}: ${stderr}`));
+          }
+        });
+        proc.on('error', reject);
+      });
+      
+    } else if (process.platform === 'linux') {
+      // Linux: use notify-send
+      const { spawn } = require('child_process');
+      await new Promise<void>((resolve, reject) => {
+        const proc = spawn('notify-send', [
+          '--urgency', urgency,
+          '--icon', icon,
+          '--expire-time', timeout.toString(),
+          title,
+          message
+        ]);
+        proc.on('exit', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`notify-send failed with code ${code}`));
+        });
+        proc.on('error', reject);
+      });
+
+    } else if (process.platform === 'win32') {
+      // Windows: use PowerShell toast notifications
+      const { spawn } = require('child_process');
+      const powershellScript = `
+        Add-Type -AssemblyName System.Windows.Forms
+        $notification = New-Object System.Windows.Forms.NotifyIcon
+        $notification.Icon = [System.Drawing.SystemIcons]::Information
+        $notification.BalloonTipTitle = "${title}"
+        $notification.BalloonTipText = "${message}"
+        $notification.BalloonTipIcon = "Info"
+        $notification.Visible = $true
+        $notification.ShowBalloonTip(${timeout})
+        Start-Sleep -Milliseconds ${timeout + 1000}
+        $notification.Dispose()
+      `;
+      
+      await new Promise<void>((resolve, reject) => {
+        const proc = spawn('powershell', ['-Command', powershellScript]);
+        proc.on('exit', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`PowerShell failed with code ${code}`));
+        });
+        proc.on('error', reject);
+      });
+    }
+  } catch (error) {
+    console.warn('Failed to send OS notification:', error);
+    // Fallback to terminal notification
+    sendTerminalNotification(title, message, { sound: false });
+  }
+}
+
+// Combined notification - sends both terminal and OS notifications
+export function sendNotification(
+  title: string, 
+  message: string, 
+  options?: {
+    osNotification?: boolean;
+    terminalNotification?: boolean;
+    sound?: boolean;
+  }
+) {
+  const {
+    osNotification = true,
+    terminalNotification = true,
+    sound = true
+  } = options || {};
+  
+  if (terminalNotification) {
+    sendTerminalNotification(title, message, { sound });
+  }
+  
+  if (osNotification) {
+    sendOSNotification(title, message, { sound });
+  }
+}
+
+// Check if notifications are available
+export async function checkNotificationSupport(): Promise<{
+  terminalSupported: boolean;
+  osSupported: boolean;
+  platform: string;
+}> {
+  return {
+    terminalSupported: true, // Always supported
+    osSupported: process.platform === 'darwin' || process.platform === 'linux' || process.platform === 'win32',
+    platform: process.platform
+  };
+}

package/src/utils/object-utils.ts

@@ -0,0 +1,51 @@
+/**
+ * Object utility functions
+ * Helper functions for working with nested objects
+ */
+
+/**
+ * Get a nested property from an object using dot notation
+ */
+export function getNestedProperty(obj: Record<string, unknown>, path: string): unknown {
+  const keys = path.split('.');
+  return keys.reduce((current, key) => current?.[key], obj);
+}
+
+/**
+ * Set a nested property on an object using dot notation
+ */
+export function setNestedProperty(
+  obj: Record<string, unknown>,
+  path: string,
+  value: unknown
+): void {
+  const keys = path.split('.');
+  const lastKey = keys.pop()!;
+
+  const target = keys.reduce((current, key) => {
+    if (current[key] === undefined || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    return current[key] as Record<string, unknown>;
+  }, obj);
+
+  target[lastKey] = value;
+}
+
+/**
+ * Delete a nested property from an object using dot notation
+ */
+export function deleteNestedProperty(obj: Record<string, unknown>, path: string): void {
+  const keys = path.split('.');
+  const lastKey = keys.pop()!;
+
+  const target = keys.reduce((current, key) => {
+    if (current[key] === undefined || typeof current[key] !== 'object') {
+      current[key] = {};
+      return current[key] as Record<string, unknown>;
+    }
+    return current[key] as Record<string, unknown>;
+  }, obj);
+
+  delete target[lastKey];
+}