langtrain 0.1.14 → 0.1.16

package/src/cli/index.ts

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import path from 'path';
+import { bgCyan, black, red, select, isCancel, outro, intro, gray } from './ui'; // Ensure clear is exported if added, otherwise use console.clear()
+import { showBanner } from './ui';
+import { ensureAuth, handleLogin, getSubscription } from './auth';
+import { getMenu, MenuState } from './menu';
+import { getConfig } from './config';
+
+// Handlers
+import { handleSubscriptionStatus } from './handlers/subscription';
+import { handleTuneFinetune, handleTuneGenerate } from './handlers/tune';
+import { handleVisionFinetune, handleVisionGenerate } from './handlers/vision';
+import { handleAgentCreate, handleAgentDelete, handleAgentList } from './handlers/agent';
+
+// Clients
+import { SubscriptionInfo, Langvision, Langtune, AgentClient, ModelClient } from '../index';
+import packageJson from '../../package.json';
+
+export async function main() {
+    const program = new Command();
+    const version = packageJson.version;
+
+    program
+        .name('langtrain')
+        .description(packageJson.description || 'Langtrain CLI for AI Model Fine-tuning and Generation')
+        .version(version);
+
+    program.action(async () => {
+        showBanner(version);
+
+        // 1. Auth & Plan Check Force
+        // 1. Auth & Plan Check (Lazy)
+        // 0. First Run Check
+        const isFirstRun = process.argv.includes('--first-run');
+        if (isFirstRun) {
+            // Check if interactive
+            if (process.stdin.isTTY) {
+                intro('Welcome to Langtrain! Let\'s get you set up.');
+                await handleLogin();
+                // Reload config after login
+            } else {
+                console.log('Langtrain installed! Run "npx langtrain login" to authenticate.');
+                process.exit(0);
+            }
+        }
+
+        // 1. Auth & Plan Check (Lazy)
+        let config = getConfig();
+        let apiKey = config.apiKey || '';
+        let plan: SubscriptionInfo | null = null;
+
+        // Try to fetch plan if key exists? 
+        if (apiKey) {
+            try { plan = await getSubscription(apiKey); } catch { }
+        }
+
+        // 2. Global Client Init
+        let clients = {
+            vision: new Langvision({ apiKey }),
+            tune: new Langtune({ apiKey }),
+            agent: new AgentClient({ apiKey, baseUrl: config.baseUrl }),
+            model: new ModelClient({ apiKey, baseUrl: config.baseUrl })
+        };
+
+        // 3. Navigation Loop
+        let currentState: MenuState = 'main';
+
+        while (true) {
+            // Clear screen for clean sub-menu navigation?
+            // Maybe not full clear to keep banner, but at least separate visual blocks.
+            // showBanner(version); // Re-showing banner might be too much flickering.
+            // console.log(''); // simple spacer
+
+            const operation = await select({
+                message: getMessageForState(currentState),
+                options: getMenu(currentState, plan, !!apiKey)
+            });
+
+            if (isCancel(operation)) {
+                if (currentState === 'main') {
+                    outro('Goodbye!');
+                    process.exit(0);
+                } else {
+                    currentState = 'main';
+                    continue;
+                }
+            }
+
+            const op = operation as string;
+
+            // Navigation Logic
+            if (op === 'exit') {
+                outro('Goodbye!');
+                process.exit(0);
+            }
+            if (op === 'back') {
+                currentState = 'main';
+                continue;
+            }
+            if (op.startsWith('nav-')) {
+                currentState = op.replace('nav-', '') as MenuState;
+                continue;
+            }
+
+            // Action Logic
+            try {
+                switch (op) {
+                    case 'login':
+                        await handleLogin();
+                        config = getConfig();
+                        apiKey = config.apiKey || '';
+                        clients = {
+                            vision: new Langvision({ apiKey }),
+                            tune: new Langtune({ apiKey }),
+                            agent: new AgentClient({ apiKey, baseUrl: config.baseUrl }),
+                            model: new ModelClient({ apiKey, baseUrl: config.baseUrl })
+                        };
+                        try { plan = await getSubscription(apiKey); } catch { }
+                        break;
+                    case 'status': await handleSubscriptionStatus(); break;
+                    case 'tune-finetune': await handleTuneFinetune(clients.tune, clients.model); break;
+                    case 'tune-generate': await handleTuneGenerate(clients.tune); break;
+                    case 'vision-finetune': await handleVisionFinetune(clients.vision, clients.model); break;
+                    case 'vision-generate': await handleVisionGenerate(clients.vision); break;
+                    case 'agent-list': await handleAgentList(clients.agent); break;
+                    case 'agent-create': await handleAgentCreate(clients.agent, clients.model); break;
+                    case 'agent-delete': await handleAgentDelete(clients.agent); break;
+                }
+
+                // After action, where do we go? 
+                // Stay in current state (sub-menu) is usually preferred.
+
+            } catch (error: any) {
+                outro(red(`Error: ${error.message}`));
+            }
+        }
+    });
+
+    program.parse(process.argv);
+}
+
+main().catch(console.error);
+
+function getMessageForState(state: MenuState): string {
+    switch (state) {
+        case 'main': return 'Main Menu:';
+        case 'agents': return 'Agents & Tools:';
+        case 'text': return 'Langtune (Text Operations):';
+        case 'vision': return 'Langvision (Vision Operations):';
+        case 'settings': return 'Settings:';
+        default: return 'Select an option:';
+    }
+}

package/src/cli/menu.ts

@@ -0,0 +1,70 @@
+import { SubscriptionInfo } from '../index';
+
+export interface MenuOption {
+    value: string;
+    label: string;
+    hint?: string;
+}
+
+export type MenuState = 'main' | 'agents' | 'text' | 'vision' | 'settings';
+
+export function getMenu(state: MenuState, plan: SubscriptionInfo | null, isAuthenticated: boolean): MenuOption[] {
+    const isPro = plan?.plan === 'pro' || plan?.plan === 'enterprise';
+
+    // If not authenticated, force login or limited menu?
+    // User requested "lazy auth", so we should show menu but maybe highlight login or allow navigation and prompt later.
+    // Let's add a visual cue.
+
+    switch (state) {
+        case 'main':
+            const menu: MenuOption[] = [
+                { value: 'nav-agents', label: 'Agents', hint: 'Manage & Chat with AI Agents' },
+                { value: 'nav-text', label: 'Langtune (Text)', hint: 'Fine-tuning & Generation' },
+                { value: 'nav-vision', label: 'Langvision (Vision)', hint: 'Vision Analysis & Tuning' },
+                { value: 'nav-settings', label: 'Settings', hint: 'Subscription & Auth' }
+            ];
+
+            if (!isAuthenticated) {
+                // menu.unshift({ value: 'login', label: 'Login to Langtrain', hint: 'Required for most features' });
+                // Actually, let's make Login the first option if not authenticated
+                // But keep the others so user can see what's available (and get prompted)
+                menu.unshift({ value: 'login', label: 'Login to Langtrain', hint: 'Required for most features' });
+            }
+
+            // Always add Exit
+            menu.push({ value: 'exit', label: 'Exit' });
+            return menu;
+
+        case 'agents':
+            return [
+                { value: 'agent-list', label: 'List & Run Agents', hint: 'View active agents' },
+                { value: 'agent-create', label: 'Create New Agent', hint: 'Deploy a new agent' },
+                { value: 'agent-delete', label: 'Delete Agent', hint: 'Remove an agent' },
+                { value: 'back', label: '← Back to Main Menu' }
+            ];
+
+        case 'text':
+            return [
+                { value: 'tune-finetune', label: 'Fine-tune Text Model', hint: 'Create custom LLM' },
+                { value: 'tune-generate', label: 'Generate Text', hint: 'Test your models' },
+                { value: 'back', label: '← Back to Main Menu' }
+            ];
+
+        case 'vision':
+            return [
+                { value: 'vision-finetune', label: 'Fine-tune Vision Model', hint: 'Create custom VLM' },
+                { value: 'vision-generate', label: 'Generate Vision Response', hint: 'Test vision models' },
+                { value: 'back', label: '← Back to Main Menu' }
+            ];
+
+        case 'settings':
+            return [
+                { value: 'status', label: isAuthenticated ? `Subscription Status (${plan?.plan || 'Free'})` : 'Check Status (Login required)' },
+                { value: 'login', label: isAuthenticated ? 'Update API Key' : 'Login' },
+                { value: 'back', label: '← Back to Main Menu' }
+            ];
+
+        default:
+            return [];
+    }
+}

package/src/cli/ui.ts

@@ -0,0 +1,50 @@
+import { text, select, confirm, password, isCancel, cancel } from '@clack/prompts';
+import { bgCyan, black, red, green, yellow, gray, cyan, bold } from 'kleur/colors';
+
+// Gradient removed for cleaner look, or keep if user likes it but wants no emojis?
+// User said "remove emojis", didn't explicitly say "remove colors/gradients", but "clean UI" usually implies less noise.
+// I will keep the banner gradient as it is a brand element, but remove emojis from intro/outro.
+import gradient from 'gradient-string';
+
+export function showBanner(version: string) {
+    console.clear();
+    const banner = `
+    ██╗      █████╗ ███╗   ██╗ ██████╗████████╗██████╗  █████╗ ██╗███╗   ██╗
+    ██║     ██╔══██╗████╗  ██║██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██║████╗  ██║
+    ██║     ███████║██╔██╗ ██║██║  ███╗  ██║   ██████╔╝███████║██║██╔██╗ ██║
+    ██║     ██╔══██║██║╚██╗██║██║   ██║  ██║   ██╔══██╗██╔══██║██║██║╚██╗██║
+    ███████╗██║  ██║██║ ╚████║╚██████╔╝  ██║   ██║  ██║██║  ██║██║██║ ╚████║
+    ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚═════╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝
+    `;
+    console.log(gradient(['#00DC82', '#36E4DA', '#0047E1'])(banner));
+    console.log(`${bgCyan(black(` Langtrain SDK v${version} `))}\n`);
+}
+
+export function intro(message: string) {
+    console.log(cyan(`◆ ${message}`));
+}
+
+export function outro(message: string) {
+    console.log(gray(`└ ${message}`));
+}
+
+export function spinner() {
+    return {
+        start: (msg: string) => process.stdout.write(`${cyan('●')} ${msg}\r`),
+        stop: (msg?: string) => {
+            if (msg) console.log(`${green('✔')} ${msg}`);
+            else console.log(''); // Newline
+        },
+        message: (msg: string) => process.stdout.write(`${cyan('●')} ${msg}\r`)
+    };
+}
+
+export function showError(message: string) {
+    console.log(red(`✖ Error: ${message}`));
+}
+
+export function showSuccess(message: string) {
+    console.log(green(`✔ ${message}`));
+}
+
+export { text, select, confirm, password, isCancel, cancel, bgCyan, black, red, green, yellow, gray, cyan, bold, gradient };

package/src/index.ts

@@ -4,14 +4,16 @@ export { Langvision } from 'langvision';
 export { Langtune } from 'langtune';
 
 // Export Agent Client
-export { AgentClient, Agent, AgentRun, AgentCreate } from './agent';
-export { FileClient, FileResponse } from './files';
-export { TrainingClient, FineTuneJobCreate, FineTuneJobResponse } from './training';
-export { SubscriptionClient, SubscriptionInfo, FeatureCheck } from './subscription';
+export { AgentClient, Agent, AgentRun, AgentCreate } from './lib/agent';
+export { FileClient, FileResponse } from './lib/files';
+export { TrainingClient, FineTuneJobCreate, FineTuneJobResponse } from './lib/training';
+export { SubscriptionClient, SubscriptionInfo, FeatureCheck } from './lib/subscription';
+export { ModelClient, Model } from './lib/models';
 
 // Export Types with Namespaces to avoid collisions
 import * as Vision from 'langvision';
 import * as Text from 'langtune';
-import * as AgentTypes from './agent';
+import * as AgentTypes from './lib/agent';
+import * as ModelTypes from './lib/models';
 
-export { Vision, Text, AgentTypes };
+export { Vision, Text, AgentTypes, ModelTypes };

package/src/{agent.ts → lib/agent.ts}

@@ -6,7 +6,7 @@ export interface Agent {
     name: string;
     description?: string;
     model_id?: string;
-    config: any;
+    config: Record<string, unknown>;
     is_active: boolean;
     created_at: string;
     updated_at: string;
@@ -16,7 +16,7 @@ export interface AgentRun {
     id: string;
     conversation_id: string;
     success: boolean;
-    output?: any;
+    output?: unknown;
     error?: string;
     latency_ms: number;
     tokens_used: number;

package/src/lib/models.ts

@@ -0,0 +1,61 @@
+import axios, { AxiosInstance } from 'axios';
+
+export interface Permission {
+    id: string;
+    object: string;
+    created: number;
+    allow_create_engine: boolean;
+    allow_sampling: boolean;
+    allow_logprobs: boolean;
+    allow_search_indices: boolean;
+    allow_view: boolean;
+    allow_fine_tuning: boolean;
+    organization: string;
+    group: any;
+    is_blocking: boolean;
+}
+
+export interface Model {
+    id: string;
+    object: string; // 'model'
+    created: number;
+    owned_by: string;
+    permission: Permission[];
+    root: string;
+    parent: string | null;
+    task?: 'text' | 'vision' | 'agent';
+}
+
+export class ModelClient {
+    private client: AxiosInstance;
+
+    constructor(config: { apiKey: string, baseUrl?: string }) {
+        this.client = axios.create({
+            baseURL: config.baseUrl || 'https://api.langtrain.ai/api/v1',
+            headers: {
+                'X-API-Key': config.apiKey,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async list(task?: string): Promise<Model[]> {
+        const params: any = {};
+        if (task) params.task = task;
+
+        try {
+            const response = await this.client.get<{ data: Model[] }>('/models', { params });
+            return response.data.data;
+        } catch (error) {
+            // Fallback if endpoint doesn't support filtering or fails
+            // Verify if /models exists, otherwise return empty or throw
+            // customized error handling could go here
+            throw error;
+        }
+    }
+
+    async get(modelId: string): Promise<Model> {
+        const response = await this.client.get<Model>(`/models/${modelId}`);
+        return response.data;
+    }
+}

package/tsup.config.ts

@@ -1,11 +1,16 @@
 import { defineConfig } from 'tsup';
 
 export default defineConfig({
-    entry: ['src/index.ts', 'src/cli.ts'],
+    entry: {
+        index: 'src/index.ts',
+        cli: 'src/cli/index.ts',
+    },
     format: ['cjs', 'esm'],
     dts: true,
-    splitting: false,
+    splitting: true,
     sourcemap: true,
     clean: true,
+    minify: true,
+    treeshake: true,
     noExternal: ['langvision', 'langtune'],
 });