@appkit/llamacpp-cli 1.3.2 → 1.4.1

package/src/lib/model-scanner.ts

@@ -5,18 +5,34 @@ import { getModelsDir } from '../utils/file-utils';
 import { formatBytes } from '../utils/format-utils';
 
 export class ModelScanner {
-  private modelsDir: string;
+  private modelsDir?: string;
+  private getModelsDirFn?: () => Promise<string>;
 
-  constructor(modelsDir?: string) {
-    this.modelsDir = modelsDir || getModelsDir();
+  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(this.modelsDir);
+      const files = await fs.readdir(modelsDir);
       const ggufFiles = files.filter((f) => f.toLowerCase().endsWith('.gguf'));
 
       const models: ModelInfo[] = [];
@@ -41,7 +57,8 @@ export class ModelScanner {
    * Get information about a specific model file
    */
   async getModelInfo(filename: string): Promise<ModelInfo | null> {
-    const modelPath = path.join(this.modelsDir, filename);
+    const modelsDir = await this.getModelsDirectory();
+    const modelPath = path.join(modelsDir, filename);
 
     try {
       const stats = await fs.stat(modelPath);
@@ -84,8 +101,10 @@ export class ModelScanner {
       return filename;
     }
 
+    const modelsDir = await this.getModelsDirectory();
+
     // Try in models directory
-    const modelPath = path.join(this.modelsDir, filename);
+    const modelPath = path.join(modelsDir, filename);
     const modelInfo = await this.getModelInfo(filename);
 
     if (modelInfo && modelInfo.exists) {
@@ -97,7 +116,7 @@ export class ModelScanner {
       const withExtension = `${filename}.gguf`;
       const modelInfoWithExt = await this.getModelInfo(withExtension);
       if (modelInfoWithExt && modelInfoWithExt.exists) {
-        return path.join(this.modelsDir, withExtension);
+        return path.join(modelsDir, withExtension);
       }
     }
 
@@ -121,5 +140,18 @@ export class ModelScanner {
   }
 }
 
-// Export singleton instance
-export const modelScanner = new ModelScanner();
+// 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/models-dir-setup.ts

@@ -0,0 +1,46 @@
+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;
+}

package/src/lib/state-manager.ts

@@ -183,6 +183,23 @@ export class StateManager {
     const servers = await this.getAllServers();
     return new Set(servers.map((s) => s.port));
   }
+
+  /**
+   * Get the configured models directory
+   */
+  async getModelsDirectory(): Promise<string> {
+    const config = await this.loadGlobalConfig();
+    return config.modelsDirectory;
+  }
+
+  /**
+   * Set the models directory
+   */
+  async setModelsDirectory(directory: string): Promise<void> {
+    const config = await this.loadGlobalConfig();
+    config.modelsDirectory = directory;
+    await this.saveGlobalConfig(config);
+  }
 }
 
 // Export singleton instance

package/src/utils/file-utils.ts

@@ -82,10 +82,10 @@ export function getGlobalConfigPath(): string {
 }
 
 /**
- * Get the models directory (~/models)
+ * Get the default models directory (~/.llamacpp/models)
  */
 export function getModelsDir(): string {
-  return path.join(os.homedir(), 'models');
+  return path.join(getConfigDir(), 'models');
 }
 
 /**

package/src/utils/prompt-utils.ts

@@ -0,0 +1,47 @@
+import * as readline from 'readline';
+
+/**
+ * Prompt user for input
+ */
+export function prompt(question: string, defaultValue?: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const promptText = defaultValue
+      ? `${question} [${defaultValue}]: `
+      : `${question}: `;
+
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+/**
+ * Prompt user for yes/no confirmation
+ */
+export function confirm(question: string, defaultYes = true): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const suffix = defaultYes ? '[Y/n]' : '[y/N]';
+
+  return new Promise((resolve) => {
+    rl.question(`${question} ${suffix}: `, (answer) => {
+      rl.close();
+      const input = answer.trim().toLowerCase();
+
+      if (input === '') {
+        resolve(defaultYes);
+      } else {
+        resolve(input === 'y' || input === 'yes');
+      }
+    });
+  });
+}