@appkit/llamacpp-cli 1.0.0

package/src/commands/rm.ts

@@ -0,0 +1,114 @@
+import chalk from 'chalk';
+import * as readline from 'readline';
+import * as fs from 'fs/promises';
+import { modelScanner } from '../lib/model-scanner';
+import { stateManager } from '../lib/state-manager';
+import { launchctlManager } from '../lib/launchctl-manager';
+
+export async function rmCommand(modelIdentifier: string): Promise<void> {
+  await stateManager.initialize();
+
+  // 1. Resolve model path
+  const modelPath = await modelScanner.resolveModelPath(modelIdentifier);
+  if (!modelPath) {
+    throw new Error(`Model not found: ${modelIdentifier}\n\nRun: llamacpp ls`);
+  }
+
+  // 2. Check if any servers are using this model
+  const allServers = await stateManager.getAllServers();
+  const serversUsingModel = allServers.filter((s) => s.modelPath === modelPath);
+
+  // 3. Confirm deletion
+  console.log(chalk.yellow(`⚠️  Delete model file: ${modelPath}`));
+
+  if (serversUsingModel.length > 0) {
+    console.log(chalk.yellow(`\n   This model has ${serversUsingModel.length} server(s) configured:`));
+    for (const server of serversUsingModel) {
+      const statusColor = server.status === 'running' ? chalk.green : chalk.dim;
+      console.log(chalk.yellow(`   - ${server.id} (${statusColor(server.status)})`));
+    }
+    console.log(chalk.yellow(`\n   These servers will be removed before deleting the model.`));
+  }
+
+  console.log();
+
+  const confirmed = await confirmDeletion();
+  if (!confirmed) {
+    console.log(chalk.dim('Cancelled'));
+    return;
+  }
+
+  console.log();
+
+  // 4. Delete all servers using this model
+  if (serversUsingModel.length > 0) {
+    console.log(chalk.blue(`🗑️  Removing ${serversUsingModel.length} server(s)...\n`));
+
+    for (const server of serversUsingModel) {
+      console.log(chalk.dim(`  Removing server: ${server.id}`));
+
+      // Stop server if running
+      if (server.status === 'running') {
+        try {
+          await launchctlManager.stopService(server.label);
+          await launchctlManager.waitForServiceStop(server.label, 5000);
+        } catch (error) {
+          console.log(chalk.yellow(`    ⚠️  Failed to stop server gracefully`));
+        }
+      }
+
+      // Unload service
+      try {
+        await launchctlManager.unloadService(server.plistPath);
+      } catch (error) {
+        // Ignore errors if service is already unloaded
+      }
+
+      // Delete plist
+      await launchctlManager.deletePlist(server.plistPath);
+
+      // Delete server config
+      await stateManager.deleteServerConfig(server.id);
+
+      console.log(chalk.dim(`    ✓ Server removed`));
+    }
+
+    console.log();
+  }
+
+  // 5. Delete model file
+  console.log(chalk.blue(`🗑️  Deleting model file...`));
+
+  try {
+    await fs.unlink(modelPath);
+  } catch (error) {
+    throw new Error(`Failed to delete model file: ${(error as Error).message}`);
+  }
+
+  // Success
+  console.log();
+  console.log(chalk.green('✅ Model deleted successfully'));
+
+  if (serversUsingModel.length > 0) {
+    console.log(chalk.dim(`   Removed ${serversUsingModel.length} server(s)`));
+  }
+
+  console.log(chalk.dim(`   Deleted: ${modelPath}`));
+}
+
+/**
+ * Prompt user for confirmation
+ */
+function confirmDeletion(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(chalk.yellow("   Type 'yes' to confirm: "), (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'yes');
+    });
+  });
+}

package/src/commands/run.ts

@@ -0,0 +1,209 @@
+import chalk from 'chalk';
+import * as readline from 'readline';
+import { stateManager } from '../lib/state-manager';
+import { startCommand } from './start';
+import { statusChecker } from '../lib/status-checker';
+import { ServerConfig } from '../types/server-config';
+
+interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+interface ChatCompletionChunk {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    delta: {
+      role?: string;
+      content?: string;
+    };
+    finish_reason: string | null;
+  }>;
+}
+
+export async function runCommand(modelIdentifier: string): Promise<void> {
+  await stateManager.initialize();
+
+  // 1. Find or start server
+  let server = await stateManager.findServer(modelIdentifier);
+
+  if (!server) {
+    // Try to resolve as a model name and start it
+    console.log(chalk.blue(`🚀 No running server found. Starting ${modelIdentifier}...\n`));
+    try {
+      await startCommand(modelIdentifier, {});
+      server = await stateManager.findServer(modelIdentifier);
+      if (!server) {
+        throw new Error('Failed to start server');
+      }
+      console.log(); // Add blank line after start output
+    } catch (error) {
+      throw new Error(`Failed to start server: ${(error as Error).message}`);
+    }
+  }
+
+  // 2. Verify server is running
+  const status = await statusChecker.checkServer(server);
+  if (!status.isRunning) {
+    throw new Error(`Server exists but is not running. Start it with: llamacpp start ${server.id}`);
+  }
+
+  // 3. Start REPL
+  console.log(chalk.green(`💬 Connected to ${server.modelName} (port ${server.port})`));
+  console.log(chalk.dim(`Type your message and press Enter. Use /exit to quit, /clear to reset history, /help for commands.\n`));
+
+  const conversationHistory: ChatMessage[] = [];
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk.cyan('You: '),
+  });
+
+  // Handle graceful shutdown
+  const cleanup = () => {
+    rl.close();
+    console.log(chalk.dim('\n\nGoodbye!'));
+    process.exit(0);
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  rl.prompt();
+
+  rl.on('line', async (input: string) => {
+    const line = input.trim();
+
+    // Handle special commands
+    if (line === '/exit' || line === '/quit') {
+      cleanup();
+      return;
+    }
+
+    if (line === '/clear') {
+      conversationHistory.length = 0;
+      console.log(chalk.dim('✓ Conversation history cleared\n'));
+      rl.prompt();
+      return;
+    }
+
+    if (line === '/help') {
+      console.log(chalk.bold('\nAvailable commands:'));
+      console.log(chalk.dim('  /exit, /quit  - Exit the chat'));
+      console.log(chalk.dim('  /clear        - Clear conversation history'));
+      console.log(chalk.dim('  /help         - Show this help message\n'));
+      rl.prompt();
+      return;
+    }
+
+    if (!line) {
+      rl.prompt();
+      return;
+    }
+
+    // Add user message to history
+    conversationHistory.push({
+      role: 'user',
+      content: line,
+    });
+
+    // Send to API and stream response
+    try {
+      await streamChatCompletion(server, conversationHistory);
+      console.log(); // Blank line after response
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+    }
+
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    cleanup();
+  });
+}
+
+async function streamChatCompletion(
+  server: ServerConfig,
+  messages: ChatMessage[]
+): Promise<void> {
+  const url = `http://localhost:${server.port}/v1/chat/completions`;
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: server.modelName,
+      messages: messages,
+      stream: true,
+      temperature: 0.7,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API request failed (${response.status}): ${errorText}`);
+  }
+
+  if (!response.body) {
+    throw new Error('Response body is null');
+  }
+
+  // Display assistant prefix
+  process.stdout.write(chalk.magenta('Assistant: '));
+
+  let fullResponse = '';
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value, { stream: true });
+      const lines = chunk.split('\n').filter((line) => line.trim().startsWith('data:'));
+
+      for (const line of lines) {
+        const data = line.replace(/^data:\s*/, '').trim();
+
+        if (data === '[DONE]') {
+          continue;
+        }
+
+        if (!data) {
+          continue;
+        }
+
+        try {
+          const parsed: ChatCompletionChunk = JSON.parse(data);
+          const content = parsed.choices[0]?.delta?.content;
+
+          if (content) {
+            process.stdout.write(content);
+            fullResponse += content;
+          }
+        } catch (parseError) {
+          // Skip malformed JSON chunks
+          continue;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  // Add assistant response to history
+  if (fullResponse) {
+    messages.push({
+      role: 'assistant',
+      content: fullResponse,
+    });
+  }
+}

package/src/commands/search.ts

@@ -0,0 +1,107 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { modelSearch } from '../lib/model-search';
+import { formatBytes } from '../utils/format-utils';
+
+interface SearchOptions {
+  limit?: number;
+  files?: number | boolean;
+}
+
+export async function searchCommand(query: string, options: SearchOptions): Promise<void> {
+  const limit = options.limit || 20;
+
+  console.log(chalk.blue(`🔍 Searching Hugging Face for: "${query}"\n`));
+
+  try {
+    const results = await modelSearch.searchModels(query, limit);
+
+    if (results.length === 0) {
+      console.log(chalk.yellow('No models found.'));
+      console.log(chalk.dim('Try a different search query or browse: https://huggingface.co/models'));
+      return;
+    }
+
+    const table = new Table({
+      head: ['#', 'MODEL ID', 'DOWNLOADS', 'LIKES'],
+      colWidths: [4, 55, 12, 8],
+    });
+
+    for (let i = 0; i < results.length; i++) {
+      const model = results[i];
+      table.push([
+        chalk.dim((i + 1).toString()),
+        model.modelId,
+        model.downloads.toLocaleString(),
+        model.likes.toString(),
+      ]);
+    }
+
+    console.log(table.toString());
+
+    console.log(chalk.dim(`\nShowing ${results.length} results`));
+    console.log(chalk.dim('\nTo see files in a model:'));
+    console.log(chalk.dim('  llamacpp search "<query>" --files <number>'));
+    console.log(chalk.dim('  Example: llamacpp search "llama 3b" --files 1'));
+    console.log(chalk.dim('\nTo download:'));
+    console.log(chalk.dim('  llamacpp pull <model-id>/<file.gguf>'));
+
+    // Handle --files flag
+    if (options.files !== undefined && options.files !== false) {
+      let selectedIndex: number;
+
+      if (typeof options.files === 'number') {
+        // User specified a number: --files 1
+        selectedIndex = options.files - 1; // Convert to 0-based index
+      } else if (results.length === 1) {
+        // No number specified but only one result
+        selectedIndex = 0;
+      } else {
+        // Multiple results but no number specified
+        console.log(chalk.yellow('\n⚠️  Multiple results found. Specify which one:'));
+        console.log(chalk.dim('  llamacpp search "<query>" --files 1'));
+        return;
+      }
+
+      // Validate index
+      if (selectedIndex < 0 || selectedIndex >= results.length) {
+        console.log(chalk.red(`\n❌ Invalid index. Please specify a number between 1 and ${results.length}`));
+        return;
+      }
+
+      await showModelFiles(results[selectedIndex].modelId, selectedIndex + 1);
+    }
+  } catch (error) {
+    throw new Error(`Search failed: ${(error as Error).message}`);
+  }
+}
+
+async function showModelFiles(modelId: string, index?: number): Promise<void> {
+  const indexPrefix = index ? chalk.dim(`[${index}] `) : '';
+  console.log(chalk.blue(`\n📦 GGUF files in ${indexPrefix}${modelId}:\n`));
+
+  try {
+    const files = await modelSearch.getModelFiles(modelId);
+
+    if (files.length === 0) {
+      console.log(chalk.yellow('No GGUF files found in this model.'));
+      return;
+    }
+
+    const table = new Table({
+      head: ['FILENAME'],
+      colWidths: [70],
+    });
+
+    for (const file of files) {
+      table.push([file]);
+    }
+
+    console.log(table.toString());
+
+    console.log(chalk.dim(`\nTo download:`));
+    console.log(chalk.dim(`  llamacpp pull ${modelId}/${files[0]}`));
+  } catch (error) {
+    console.log(chalk.yellow(`\n⚠️  Could not fetch file list: ${(error as Error).message}`));
+  }
+}

package/src/commands/show.ts

@@ -0,0 +1,207 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { modelSearch } from '../lib/model-search';
+import { modelDownloader } from '../lib/model-downloader';
+import { formatBytes } from '../utils/format-utils';
+import * as https from 'https';
+
+interface ShowOptions {
+  file?: string;
+}
+
+interface ModelDetails {
+  modelId: string;
+  author: string;
+  modelName: string;
+  downloads: number;
+  likes: number;
+  lastModified: string;
+  tags: string[];
+  library?: string;
+  license?: string;
+}
+
+interface FileDetails {
+  filename: string;
+  size: number;
+  lfs?: {
+    oid: string;
+    size: number;
+  };
+}
+
+export async function showCommand(identifier: string, options: ShowOptions): Promise<void> {
+  // Parse identifier
+  const parsed = modelDownloader.parseHFIdentifier(identifier);
+  const filename = options.file || parsed.file;
+
+  console.log(chalk.blue('📋 Fetching model information...\n'));
+
+  try {
+    // Get model details
+    const modelDetails = await getModelDetails(parsed.repo);
+
+    // Display model information
+    displayModelInfo(modelDetails);
+
+    // If specific file requested, show file details
+    if (filename) {
+      console.log(chalk.blue('\n📄 File Details:\n'));
+      await displayFileInfo(parsed.repo, filename);
+    } else {
+      // Show all GGUF files
+      console.log(chalk.blue('\n📦 Available GGUF Files:\n'));
+      await displayAllFiles(parsed.repo);
+    }
+  } catch (error) {
+    throw new Error(`Failed to fetch model details: ${(error as Error).message}`);
+  }
+}
+
+async function getModelDetails(modelId: string): Promise<ModelDetails> {
+  return new Promise((resolve, reject) => {
+    const url = `https://huggingface.co/api/models/${modelId}`;
+
+    https.get(url, (response) => {
+      let data = '';
+
+      response.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      response.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const parts = modelId.split('/');
+
+          resolve({
+            modelId,
+            author: parts[0] || '',
+            modelName: parts.slice(1).join('/') || '',
+            downloads: json.downloads || 0,
+            likes: json.likes || 0,
+            lastModified: json.lastModified || '',
+            tags: json.tags || [],
+            library: json.library_name,
+            license: json.cardData?.license,
+          });
+        } catch (error) {
+          reject(new Error(`Failed to parse model data: ${(error as Error).message}`));
+        }
+      });
+    }).on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+function displayModelInfo(details: ModelDetails): void {
+  console.log(chalk.bold('Model Information:'));
+  console.log(chalk.dim('─'.repeat(60)));
+  console.log(`${chalk.bold('ID:')}           ${details.modelId}`);
+  console.log(`${chalk.bold('Author:')}       ${details.author}`);
+  console.log(`${chalk.bold('Downloads:')}    ${details.downloads.toLocaleString()}`);
+  console.log(`${chalk.bold('Likes:')}        ${details.likes.toLocaleString()}`);
+  console.log(`${chalk.bold('Last Updated:')} ${new Date(details.lastModified).toLocaleDateString()}`);
+
+  if (details.license) {
+    console.log(`${chalk.bold('License:')}      ${details.license}`);
+  }
+
+  if (details.tags.length > 0) {
+    const relevantTags = details.tags
+      .filter(tag => !tag.startsWith('arxiv:') && !tag.startsWith('dataset:'))
+      .slice(0, 5);
+    if (relevantTags.length > 0) {
+      console.log(`${chalk.bold('Tags:')}         ${relevantTags.join(', ')}`);
+    }
+  }
+}
+
+async function displayFileInfo(modelId: string, filename: string): Promise<void> {
+  const files = await getModelFiles(modelId);
+  const file = files.find(f => f.filename === filename);
+
+  if (!file) {
+    console.log(chalk.yellow(`⚠️  File not found: ${filename}`));
+    console.log(chalk.dim('\nAvailable files:'));
+    files.forEach(f => console.log(chalk.dim(`  - ${f.filename}`)));
+    return;
+  }
+
+  const size = file.lfs?.size || file.size || 0;
+
+  console.log(`${chalk.bold('Filename:')}     ${file.filename}`);
+  console.log(`${chalk.bold('Size:')}         ${formatBytes(size)}`);
+
+  if (file.lfs) {
+    console.log(`${chalk.bold('SHA256:')}       ${file.lfs.oid.substring(0, 16)}...`);
+  }
+
+  console.log(chalk.dim('\nTo download:'));
+  console.log(chalk.dim(`  llamacpp pull ${modelId}/${filename}`));
+}
+
+async function displayAllFiles(modelId: string): Promise<void> {
+  const files = await getModelFiles(modelId);
+  const ggufFiles = files.filter(f => f.filename.toLowerCase().endsWith('.gguf'));
+
+  if (ggufFiles.length === 0) {
+    console.log(chalk.yellow('No GGUF files found in this model.'));
+    return;
+  }
+
+  const table = new Table({
+    head: ['FILENAME', 'SIZE'],
+    colWidths: [55, 12],
+  });
+
+  for (const file of ggufFiles) {
+    // LFS files store size in the lfs object, regular files in size field
+    const size = (file.lfs && typeof file.lfs.size === 'number') ? file.lfs.size : file.size;
+    table.push([
+      file.filename,
+      size > 0 ? formatBytes(size) : chalk.dim('Unknown'),
+    ]);
+  }
+
+  console.log(table.toString());
+
+  const totalSize = ggufFiles.reduce((sum, f) => {
+    const size = (f.lfs && typeof f.lfs.size === 'number') ? f.lfs.size : f.size;
+    return sum + size;
+  }, 0);
+  console.log(chalk.dim(`\nTotal: ${ggufFiles.length} files (${formatBytes(totalSize)})`));
+  console.log(chalk.dim('\nTo download a specific file:'));
+  console.log(chalk.dim(`  llamacpp pull ${modelId}/<filename>`));
+}
+
+async function getModelFiles(modelId: string): Promise<FileDetails[]> {
+  return new Promise((resolve, reject) => {
+    const url = `https://huggingface.co/api/models/${modelId}`;
+
+    https.get(url, (response) => {
+      let data = '';
+
+      response.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      response.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const files: FileDetails[] = (json.siblings || []).map((file: any) => ({
+            filename: file.rfilename,
+            size: file.size || 0,
+            lfs: file.lfs,
+          }));
+          resolve(files);
+        } catch (error) {
+          reject(new Error(`Failed to parse file data: ${(error as Error).message}`));
+        }
+      });
+    }).on('error', (error) => {
+      reject(error);
+    });
+  });
+}