@appkit/llamacpp-cli 1.11.0 → 1.12.1

package/src/lib/model-downloader.ts

@@ -1,328 +0,0 @@
-import * as https from 'https';
-import * as fs from 'fs';
-import * as path from 'path';
-import chalk from 'chalk';
-import { getModelsDir } from '../utils/file-utils';
-import { formatBytes } from '../utils/format-utils';
-
-export interface DownloadProgress {
-  filename: string;
-  downloaded: number;
-  total: number;
-  percentage: number;
-  speed: string;
-}
-
-export interface DownloadOptions {
-  silent?: boolean;  // Suppress console output (for TUI)
-  signal?: AbortSignal;  // Abort signal for cancellation
-}
-
-export class ModelDownloader {
-  private modelsDir?: string;
-  private getModelsDirFn?: () => Promise<string>;
-
-  constructor(modelsDir?: string, getModelsDirFn?: () => Promise<string>) {
-    this.modelsDir = modelsDir;
-    this.getModelsDirFn = getModelsDirFn;
-  }
-
-  /**
-   * Get the models directory (either configured or default)
-   */
-  private async getModelsDirectory(): Promise<string> {
-    if (this.modelsDir) {
-      return this.modelsDir;
-    }
-    if (this.getModelsDirFn) {
-      return await this.getModelsDirFn();
-    }
-    return getModelsDir();
-  }
-
-  /**
-   * Parse Hugging Face identifier
-   * Examples:
-   *   "bartowski/Llama-3.2-3B-Instruct-GGUF" → { repo: "...", file: undefined }
-   *   "bartowski/Llama-3.2-3B-Instruct-GGUF/file.gguf" → { repo: "...", file: "file.gguf" }
-   */
-  parseHFIdentifier(identifier: string): { repo: string; file?: string } {
-    const parts = identifier.split('/');
-    if (parts.length === 2) {
-      return { repo: identifier };
-    } else if (parts.length === 3) {
-      return {
-        repo: `${parts[0]}/${parts[1]}`,
-        file: parts[2],
-      };
-    } else {
-      throw new Error(`Invalid Hugging Face identifier: ${identifier}`);
-    }
-  }
-
-  /**
-   * Build Hugging Face download URL
-   */
-  buildDownloadUrl(repoId: string, filename: string, branch = 'main'): string {
-    return `https://huggingface.co/${repoId}/resolve/${branch}/${filename}`;
-  }
-
-  /**
-   * Download a file via HTTPS with progress tracking
-   */
-  private downloadFile(
-    url: string,
-    destPath: string,
-    onProgress?: (downloaded: number, total: number) => void,
-    signal?: AbortSignal
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const file = fs.createWriteStream(destPath);
-      let downloadedBytes = 0;
-      let totalBytes = 0;
-      let lastUpdateTime = Date.now();
-      let lastDownloadedBytes = 0;
-      let completed = false;
-      let request: ReturnType<typeof https.get> | null = null;
-
-      const cleanup = (sigintHandler?: () => void) => {
-        if (sigintHandler) {
-          process.removeListener('SIGINT', sigintHandler);
-        }
-      };
-
-      const handleError = (err: Error, sigintHandler?: () => void) => {
-        if (completed) return;
-        completed = true;
-        cleanup(sigintHandler);
-        file.close(() => {
-          fs.unlink(destPath, () => {});
-        });
-        reject(err);
-      };
-
-      const sigintHandler = () => {
-        if (request) request.destroy();
-        handleError(new Error('Download interrupted by user'), sigintHandler);
-      };
-
-      // Handle abort signal
-      const abortHandler = () => {
-        if (request) request.destroy();
-        handleError(new Error('Download cancelled'), sigintHandler);
-      };
-
-      if (signal) {
-        if (signal.aborted) {
-          handleError(new Error('Download cancelled'), sigintHandler);
-          return;
-        }
-        signal.addEventListener('abort', abortHandler, { once: true });
-      }
-
-      request = https.get(url, { agent: new https.Agent({ keepAlive: false }) }, (response) => {
-        // Handle redirects (301, 302, 307, 308)
-        if (response.statusCode === 301 || response.statusCode === 302 ||
-            response.statusCode === 307 || response.statusCode === 308) {
-          const redirectUrl = response.headers.location;
-          if (redirectUrl) {
-            cleanup(sigintHandler);
-            if (signal) signal.removeEventListener('abort', abortHandler);
-            // Wait for file to close before starting new download
-            file.close(() => {
-              fs.unlink(destPath, () => {
-                // Start recursive download only after cleanup is complete
-                this.downloadFile(redirectUrl, destPath, onProgress, signal)
-                  .then(resolve)
-                  .catch(reject);
-              });
-            });
-            return;
-          }
-        }
-
-        if (response.statusCode !== 200) {
-          return handleError(
-            new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`),
-            sigintHandler
-          );
-        }
-
-        totalBytes = parseInt(response.headers['content-length'] || '0', 10);
-
-        response.on('data', (chunk: Buffer) => {
-          downloadedBytes += chunk.length;
-
-          // Update progress every 500ms
-          const now = Date.now();
-          if (onProgress && now - lastUpdateTime >= 500) {
-            onProgress(downloadedBytes, totalBytes);
-            lastUpdateTime = now;
-            lastDownloadedBytes = downloadedBytes;
-          }
-        });
-
-        response.pipe(file);
-
-        file.on('finish', () => {
-          if (completed) return;
-          completed = true;
-
-          // Final progress update
-          if (onProgress) {
-            onProgress(downloadedBytes, totalBytes);
-          }
-
-          // Use callback to ensure close completes before resolving
-          file.close((err) => {
-            cleanup(sigintHandler);
-            if (signal) signal.removeEventListener('abort', abortHandler);
-            if (err) reject(err);
-            else resolve();
-          });
-        });
-      });
-
-      request.on('error', (err) => {
-        if (signal) signal.removeEventListener('abort', abortHandler);
-        handleError(err, sigintHandler);
-      });
-
-      file.on('error', (err) => {
-        if (signal) signal.removeEventListener('abort', abortHandler);
-        handleError(err, sigintHandler);
-      });
-
-      // Handle Ctrl+C gracefully
-      process.on('SIGINT', sigintHandler);
-    });
-  }
-
-  /**
-   * Display progress bar
-   */
-  private displayProgress(downloaded: number, total: number, filename: string): void {
-    const percentage = total > 0 ? (downloaded / total) * 100 : 0;
-    const barLength = 40;
-    const filledLength = Math.round((barLength * downloaded) / total);
-    const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
-
-    const downloadedFormatted = formatBytes(downloaded);
-    const totalFormatted = formatBytes(total);
-    const percentFormatted = percentage.toFixed(1);
-
-    // Clear line and print progress
-    process.stdout.write('\r\x1b[K');
-    process.stdout.write(
-      chalk.blue(`[${bar}] ${percentFormatted}% | ${downloadedFormatted} / ${totalFormatted}`)
-    );
-  }
-
-  /**
-   * Download a model from Hugging Face
-   */
-  async downloadModel(
-    repoId: string,
-    filename: string,
-    onProgress?: (progress: DownloadProgress) => void,
-    modelsDir?: string,
-    options?: DownloadOptions
-  ): Promise<string> {
-    const silent = options?.silent ?? false;
-    const signal = options?.signal;
-
-    // Use provided models directory or get from config
-    const targetDir = modelsDir || await this.getModelsDirectory();
-
-    if (!silent) {
-      console.log(chalk.blue(`📥 Downloading ${filename} from Hugging Face...`));
-      console.log(chalk.dim(`Repository: ${repoId}`));
-      console.log(chalk.dim(`Destination: ${targetDir}`));
-      console.log();
-    }
-
-    // Build download URL
-    const url = this.buildDownloadUrl(repoId, filename);
-    const destPath = path.join(targetDir, filename);
-
-    // Check if file already exists
-    if (fs.existsSync(destPath)) {
-      if (!silent) {
-        console.log(chalk.yellow(`⚠️  File already exists: ${filename}`));
-        console.log(chalk.dim('   Remove it first or choose a different filename'));
-      }
-      throw new Error('File already exists');
-    }
-
-    // Download with progress
-    const startTime = Date.now();
-    let lastDownloaded = 0;
-    let lastTime = startTime;
-
-    await this.downloadFile(url, destPath, (downloaded, total) => {
-      // Calculate speed
-      const now = Date.now();
-      const timeDiff = (now - lastTime) / 1000; // seconds
-      const bytesDiff = downloaded - lastDownloaded;
-      const speed = timeDiff > 0 ? bytesDiff / timeDiff : 0;
-
-      // Update for next calculation
-      lastTime = now;
-      lastDownloaded = downloaded;
-
-      // Display progress bar (only if not silent)
-      if (!silent) {
-        this.displayProgress(downloaded, total, filename);
-      }
-
-      // Call user progress callback if provided
-      if (onProgress) {
-        onProgress({
-          filename,
-          downloaded,
-          total,
-          percentage: total > 0 ? (downloaded / total) * 100 : 0,
-          speed: `${formatBytes(speed)}/s`,
-        });
-      }
-    }, signal);
-
-    if (!silent) {
-      // Clear progress line and show completion
-      process.stdout.write('\r\x1b[K');
-      console.log(chalk.green('✅ Download complete!'));
-
-      const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
-      console.log(chalk.dim(`   Time: ${totalTime}s`));
-      console.log(chalk.dim(`   Location: ${destPath}`));
-    }
-
-    return destPath;
-  }
-
-  /**
-   * List GGUF files in a Hugging Face repository
-   * (This would require calling the HF API - simplified for now)
-   */
-  async listGGUFFiles(repoId: string): Promise<string[]> {
-    console.log(chalk.yellow('Listing files is not yet implemented.'));
-    console.log(chalk.dim('Please specify the file with --file <filename>'));
-    return [];
-  }
-}
-
-// Create singleton that uses configured models directory
-// Use lazy import to avoid circular dependency
-let _modelDownloader: ModelDownloader | null = null;
-
-export function getModelDownloader(): ModelDownloader {
-  if (!_modelDownloader) {
-    // Import stateManager dynamically to avoid circular dependency
-    const { stateManager } = require('./state-manager');
-    _modelDownloader = new ModelDownloader(undefined, () => stateManager.getModelsDirectory());
-  }
-  return _modelDownloader;
-}
-
-// Export singleton instance for backward compatibility
-export const modelDownloader = getModelDownloader();

package/src/lib/model-scanner.ts

@@ -1,157 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { ModelInfo } from '../types/model-info';
-import { getModelsDir } from '../utils/file-utils';
-import { formatBytes } from '../utils/format-utils';
-
-export class ModelScanner {
-  private modelsDir?: string;
-  private getModelsDirFn?: () => Promise<string>;
-
-  constructor(modelsDir?: string, getModelsDirFn?: () => Promise<string>) {
-    this.modelsDir = modelsDir;
-    this.getModelsDirFn = getModelsDirFn;
-  }
-
-  /**
-   * Get the models directory (either configured or default)
-   */
-  private async getModelsDirectory(): Promise<string> {
-    if (this.modelsDir) {
-      return this.modelsDir;
-    }
-    if (this.getModelsDirFn) {
-      return await this.getModelsDirFn();
-    }
-    return getModelsDir();
-  }
-
-  /**
-   * Scan models directory for GGUF files
-   */
-  async scanModels(): Promise<ModelInfo[]> {
-    const modelsDir = await this.getModelsDirectory();
-    try {
-      const files = await fs.readdir(modelsDir);
-      const ggufFiles = files.filter((f) => f.toLowerCase().endsWith('.gguf'));
-
-      const models: ModelInfo[] = [];
-      for (const file of ggufFiles) {
-        const modelInfo = await this.getModelInfo(file);
-        if (modelInfo) {
-          models.push(modelInfo);
-        }
-      }
-
-      // Sort by modified date (newest first)
-      models.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-
-      return models;
-    } catch (error) {
-      // Models directory doesn't exist or is not accessible
-      return [];
-    }
-  }
-
-  /**
-   * Get information about a specific model file
-   */
-  async getModelInfo(filename: string): Promise<ModelInfo | null> {
-    const modelsDir = await this.getModelsDirectory();
-    const modelPath = path.join(modelsDir, filename);
-
-    try {
-      const stats = await fs.stat(modelPath);
-
-      return {
-        filename,
-        path: modelPath,
-        size: stats.size,
-        sizeFormatted: formatBytes(stats.size),
-        modified: stats.mtime,
-        exists: true,
-      };
-    } catch (error) {
-      // File doesn't exist or is not accessible
-      return {
-        filename,
-        path: modelPath,
-        size: 0,
-        sizeFormatted: '0 B',
-        modified: new Date(),
-        exists: false,
-      };
-    }
-  }
-
-  /**
-   * Validate that a model file exists and is readable
-   */
-  async validateModel(filename: string): Promise<boolean> {
-    const modelInfo = await this.getModelInfo(filename);
-    return modelInfo !== null && modelInfo.exists && modelInfo.size > 0;
-  }
-
-  /**
-   * Resolve a model filename to full path
-   */
-  async resolveModelPath(filename: string): Promise<string | null> {
-    // If already absolute path, return it
-    if (path.isAbsolute(filename)) {
-      return filename;
-    }
-
-    const modelsDir = await this.getModelsDirectory();
-
-    // Try in models directory
-    const modelPath = path.join(modelsDir, filename);
-    const modelInfo = await this.getModelInfo(filename);
-
-    if (modelInfo && modelInfo.exists) {
-      return modelPath;
-    }
-
-    // Try adding .gguf extension
-    if (!filename.toLowerCase().endsWith('.gguf')) {
-      const withExtension = `${filename}.gguf`;
-      const modelInfoWithExt = await this.getModelInfo(withExtension);
-      if (modelInfoWithExt && modelInfoWithExt.exists) {
-        return path.join(modelsDir, withExtension);
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Get the size of a model file
-   */
-  async getModelSize(filename: string): Promise<number | null> {
-    const modelInfo = await this.getModelInfo(filename);
-    return modelInfo?.size || null;
-  }
-
-  /**
-   * Get total size of all models
-   */
-  async getTotalSize(): Promise<number> {
-    const models = await this.scanModels();
-    return models.reduce((total, model) => total + model.size, 0);
-  }
-}
-
-// Create singleton that uses configured models directory
-// Use lazy import to avoid circular dependency
-let _modelScanner: ModelScanner | null = null;
-
-export function getModelScanner(): ModelScanner {
-  if (!_modelScanner) {
-    // Import stateManager dynamically to avoid circular dependency
-    const { stateManager } = require('./state-manager');
-    _modelScanner = new ModelScanner(undefined, () => stateManager.getModelsDirectory());
-  }
-  return _modelScanner;
-}
-
-// Export singleton instance for backward compatibility
-export const modelScanner = getModelScanner();

package/src/lib/model-search.ts

@@ -1,114 +0,0 @@
-import * as https from 'https';
-
-export interface HFModelResult {
-  modelId: string;
-  author: string;
-  modelName: string;
-  downloads: number;
-  likes: number;
-  tags: string[];
-  lastModified: string;
-}
-
-export class ModelSearch {
-  /**
-   * Search Hugging Face for GGUF models
-   */
-  async searchModels(query: string, limit = 20): Promise<HFModelResult[]> {
-    const searchUrl = this.buildSearchUrl(query, limit);
-
-    return new Promise((resolve, reject) => {
-      https.get(searchUrl, (response) => {
-        let data = '';
-
-        response.on('data', (chunk) => {
-          data += chunk;
-        });
-
-        response.on('end', () => {
-          try {
-            const results = JSON.parse(data);
-            const models = this.parseResults(results);
-            resolve(models);
-          } catch (error) {
-            reject(new Error(`Failed to parse search results: ${(error as Error).message}`));
-          }
-        });
-      }).on('error', (error) => {
-        reject(new Error(`Search request failed: ${error.message}`));
-      });
-    });
-  }
-
-  /**
-   * Build Hugging Face search URL
-   */
-  private buildSearchUrl(query: string, limit: number): string {
-    const params = new URLSearchParams({
-      search: query,
-      filter: 'gguf',
-      sort: 'downloads',
-      direction: '-1',
-      limit: limit.toString(),
-    });
-
-    return `https://huggingface.co/api/models?${params.toString()}`;
-  }
-
-  /**
-   * Parse API results into our model format
-   */
-  private parseResults(results: any[]): HFModelResult[] {
-    return results.map((result) => {
-      const modelId = result.id || result.modelId || '';
-      const parts = modelId.split('/');
-      const author = parts[0] || '';
-      const modelName = parts.slice(1).join('/') || '';
-
-      return {
-        modelId,
-        author,
-        modelName,
-        downloads: result.downloads || 0,
-        likes: result.likes || 0,
-        tags: result.tags || [],
-        lastModified: result.lastModified || '',
-      };
-    });
-  }
-
-  /**
-   * Get GGUF files for a specific model
-   */
-  async getModelFiles(modelId: string): Promise<string[]> {
-    const apiUrl = `https://huggingface.co/api/models/${modelId}`;
-
-    return new Promise((resolve, reject) => {
-      https.get(apiUrl, (response) => {
-        let data = '';
-
-        response.on('data', (chunk) => {
-          data += chunk;
-        });
-
-        response.on('end', () => {
-          try {
-            const modelInfo = JSON.parse(data);
-            const files = modelInfo.siblings || [];
-            const ggufFiles = files
-              .filter((file: any) => file.rfilename?.toLowerCase().endsWith('.gguf'))
-              .map((file: any) => file.rfilename);
-            resolve(ggufFiles);
-          } catch (error) {
-            reject(new Error(`Failed to fetch model files: ${(error as Error).message}`));
-          }
-        });
-      }).on('error', (error) => {
-        reject(new Error(`API request failed: ${error.message}`));
-      });
-    });
-  }
-}
-
-// Export singleton instance
-export const modelSearch = new ModelSearch();

package/src/lib/models-dir-setup.ts

@@ -1,46 +0,0 @@
-import * as fs from 'fs';
-import chalk from 'chalk';
-import { stateManager } from './state-manager';
-import { expandHome } from '../utils/file-utils';
-import { prompt } from '../utils/prompt-utils';
-
-/**
- * Ensure models directory exists, prompting user if needed
- * Returns the final models directory path
- */
-export async function ensureModelsDirectory(): Promise<string> {
-  const configuredPath = await stateManager.getModelsDirectory();
-
-  // If directory exists, we're good
-  if (fs.existsSync(configuredPath)) {
-    return configuredPath;
-  }
-
-  // Directory doesn't exist - prompt user
-  console.log(chalk.yellow('⚠️  Models directory not found'));
-  console.log();
-  console.log(chalk.dim('The models directory is where GGUF model files are stored.'));
-  console.log(chalk.dim(`Configured path: ${configuredPath}`));
-  console.log();
-
-  const answer = await prompt(
-    'Enter models directory path (press Enter to use default)',
-    configuredPath
-  );
-
-  const finalPath = expandHome(answer);
-
-  // If user changed the path, update config
-  if (finalPath !== configuredPath) {
-    console.log(chalk.dim(`Updating configuration to: ${finalPath}`));
-    await stateManager.setModelsDirectory(finalPath);
-  }
-
-  // Create the directory
-  console.log(chalk.dim(`Creating directory: ${finalPath}`));
-  fs.mkdirSync(finalPath, { recursive: true, mode: 0o755 });
-  console.log(chalk.green('✅ Models directory created'));
-  console.log();
-
-  return finalPath;
-}