langtrain 0.1.14 → 0.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langtrain",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Unified JavaScript SDK for Langtrain Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,7 +11,8 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "node dist/cli.js --first-run || true"
   },
   "keywords": [
     "langtrain",
@@ -29,6 +30,7 @@
   "author": "Langtrain AI",
   "license": "MIT",
   "devDependencies": {
+    "@types/gradient-string": "^1.1.6",
     "@types/node": "^25.2.3",
     "langtune": "file:../langtune/js",
     "langvision": "file:../langvision/js",
@@ -39,8 +41,8 @@
     "@clack/prompts": "^1.0.1",
     "axios": "^1.13.5",
     "commander": "^14.0.3",
-    "conf": "^15.1.0",
     "gradient-string": "^3.0.0",
-    "kleur": "^4.1.5"
+    "kleur": "^4.1.5",
+    "langtrain": "^0.1.15"
   }
 }

package/src/cli/auth.ts

@@ -0,0 +1,76 @@
+import { password, isCancel, cancel, intro, green, yellow, red, bgCyan, black, spinner, gray } from './ui';
+import { getConfig, saveConfig } from './config';
+import { SubscriptionClient, SubscriptionInfo } from '../index';
+
+export async function ensureAuth(): Promise<string> {
+    let config = getConfig();
+
+    if (!config.apiKey) {
+        intro(yellow('Authentication required to verify plan & features.'));
+        await handleLogin();
+        config = getConfig();
+    }
+
+    return config.apiKey as string;
+}
+
+export async function handleLogin() {
+    while (true) {
+        const apiKey = await password({
+            message: 'Enter your Langtrain API Key:',
+            validate(value) {
+                if (!value || value.length === 0) return 'API Key is required';
+            },
+        });
+
+        if (isCancel(apiKey)) {
+            cancel('Operation cancelled');
+            process.exit(0);
+        }
+
+        const s = spinner();
+        s.start('Verifying API Key...');
+
+        // Verify key immediately
+        try {
+            const client = new SubscriptionClient({ apiKey: apiKey as string });
+            const info = await client.getStatus();
+
+            s.stop(green(`Authenticated as ${info.plan === 'pro' ? 'PRO' : info.plan.toUpperCase()}`));
+
+            const config = getConfig();
+            saveConfig({ ...config, apiKey: apiKey as string });
+            // intro(green('API Key saved successfully!')); // success message above is enough
+            return; // Exit loop on success
+        } catch (e: any) {
+            s.stop(red('Invalid API Key. Please try again.'));
+            // Loop continues
+        }
+    }
+}
+
+export async function getSubscription(apiKey: string): Promise<SubscriptionInfo | null> {
+    const client = new SubscriptionClient({ apiKey });
+    const s = spinner();
+    s.start('Verifying subscription plan...');
+    try {
+        const info = await client.getStatus();
+
+        // Enhance: Show plan details immediately on auth check
+        const planLabel = info.plan === 'pro' ? bgCyan(' PRO ') : info.plan.toUpperCase();
+        s.stop(green(`Authenticated as ${planLabel}`));
+
+        if (info.is_active === false) {
+            console.log(yellow('Warning: Your subscription is not active. Some features may be limited.'));
+        }
+
+        return info;
+    } catch (e: any) {
+        s.stop(red('Failed to verify subscription.'));
+        if (e.response && e.response.status === 401) {
+            console.log(red('Invalid API Key. Please run login again.'));
+            // Optionally clear key?
+        }
+        return null;
+    }
+}

package/src/cli/config.ts

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.langtrain');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export interface CLIConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    [key: string]: any;
+}
+
+export function getConfig(): CLIConfig {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    } catch {
+        return {};
+    }
+}
+
+export function saveConfig(config: CLIConfig) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/src/cli/handlers/agent.ts

@@ -0,0 +1,183 @@
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, gray, bgCyan, black, gradient } from '../ui';
+import { AgentClient, ModelClient } from '../../index';
+
+export async function handleAgentCreate(client: AgentClient, modelClient: ModelClient) {
+    const name = await text({
+        message: 'Agent Name:',
+        placeholder: 'e.g. Support Bot',
+        validate(value) {
+            if (!value || value.length === 0) return 'API Key is required';
+        },
+    });
+    if (isCancel(name)) {
+        cancel('Operation cancelled');
+        return;
+    }
+
+    const description = await text({
+        message: 'Description:',
+        placeholder: 'e.g. A helpful support assistant',
+    });
+    if (isCancel(description)) return;
+
+    const systemPrompt = await text({
+        message: 'System Prompt:',
+        placeholder: 'e.g. You are a helpful assistant.',
+        initialValue: 'You are a helpful assistant.'
+    });
+    if (isCancel(systemPrompt)) return;
+
+    // Select model
+    let model: string | symbol = 'gpt-4o';
+    const s = spinner();
+    s.start('Fetching agent models...');
+    try {
+        const models = await modelClient.list('agent');
+        s.stop(`Found ${models.length} models`);
+        if (models.length > 0) {
+            model = await select({
+                message: 'Select Agent Model:',
+                options: models.map(m => ({ value: m.id, label: m.id }))
+            });
+        }
+    } catch (e) {
+        s.stop(yellow('Could not fetch models, using default.'));
+    }
+
+    if (isCancel(model)) return;
+
+    const s2 = spinner();
+    s2.start('Creating agent...');
+
+    try {
+        const agents = await client.list();
+        let workspaceId = "";
+        if (agents.length > 0) {
+            workspaceId = agents[0].workspace_id;
+        } else {
+            s2.stop(yellow('Workspace ID needed (no existing agents found).'));
+            const wid = await text({
+                message: 'Enter Workspace ID (UUID):',
+                validate(value) {
+                    if (!value || value.length === 0) return 'Required';
+                },
+            });
+            if (isCancel(wid)) return;
+            workspaceId = wid as string;
+            s2.start('Creating agent...');
+        }
+
+        const agent = await client.create({
+            workspace_id: workspaceId,
+            name: name as string,
+            description: description as string,
+            config: {
+                system_prompt: systemPrompt as string,
+                model: model as string
+            }
+        });
+        s2.stop(green(`Agent "${agent.name}" created successfully! ID: ${agent.id}`));
+    } catch (e: any) {
+        s2.stop(red('Failed to create agent.'));
+        throw e;
+    }
+}
+
+export async function handleAgentDelete(client: AgentClient) {
+    const s = spinner();
+    s.start('Fetching agents...');
+    const agents = await client.list();
+    s.stop(`Found ${agents.length} agents`);
+
+    if (agents.length === 0) {
+        intro(yellow('No agents to delete.'));
+        return;
+    }
+
+    const agentId = await select({
+        message: 'Select an agent to DELETE:',
+        options: agents.map(a => ({ value: a.id, label: a.name, hint: a.description || 'No description' }))
+    });
+
+    if (isCancel(agentId)) return;
+
+    const confirmDel = await select({
+        message: `Are you sure you want to delete this agent?`,
+        options: [
+            { value: 'yes', label: 'Yes, delete it', hint: 'Cannot be undone' },
+            { value: 'no', label: 'No, keep it' }
+        ]
+    });
+
+    if (confirmDel !== 'yes') {
+        intro(gray('Deletion cancelled.'));
+        return;
+    }
+
+    const d = spinner();
+    d.start('Deleting agent...');
+    try {
+        await client.delete(agentId as string);
+        d.stop(green('Agent deleted successfully.'));
+    } catch (e: any) {
+        d.stop(red('Failed to delete agent.'));
+        throw e;
+    }
+}
+
+export async function handleAgentList(client: AgentClient) {
+    const s = spinner();
+    s.start('Fetching agents...');
+    const agents = await client.list();
+    s.stop(`Found ${agents.length} agents`);
+
+    if (agents.length === 0) {
+        intro(yellow('No agents found in your workspace.'));
+        return;
+    }
+
+    const agentId = await select({
+        message: 'Select an agent to run:',
+        options: agents.map(a => ({ value: a.id, label: a.name, hint: a.description || 'No description' }))
+    });
+
+    if (isCancel(agentId)) return;
+
+    await handleAgentRun(client, agentId as string, agents.find(a => a.id === agentId)?.name || 'Agent');
+}
+
+async function handleAgentRun(client: AgentClient, agentId: string, agentName: string) {
+    intro(bgCyan(black(` Chatting with ${agentName} `)));
+    console.log(gray('Type "exit" to quit conversation.'));
+
+    let conversationId: string | undefined = undefined;
+
+    while (true) {
+        const input = await text({
+            message: 'You:',
+            placeholder: 'Type a message...',
+        });
+
+        if (isCancel(input) || input === 'exit') {
+            break;
+        }
+
+        const s = spinner();
+        s.start('Agent is thinking...');
+        try {
+            const result = await client.execute(agentId, { prompt: input }, [], conversationId);
+            s.stop();
+
+            if (result.output && result.output.response) {
+                console.log(gradient.pastel(`Agent: ${result.output.response}`));
+            } else {
+                console.log(gradient.pastel(`Agent: ${JSON.stringify(result.output)}`));
+            }
+
+            conversationId = result.conversation_id;
+        } catch (e: any) {
+            s.stop(red('Error running agent.'));
+            console.error(e);
+        }
+    }
+}

package/src/cli/handlers/subscription.ts

@@ -0,0 +1,30 @@
+import { spinner, intro, red, green, gray, bgCyan } from '../ui';
+import { getConfig } from '../config';
+import { SubscriptionClient } from '../../index';
+
+export async function handleSubscriptionStatus() {
+    const config = getConfig();
+    if (!config.apiKey) {
+        intro(red('Not logged in. Run "login" first.'));
+        return;
+    }
+    const client = new SubscriptionClient({ apiKey: config.apiKey });
+    const s = spinner();
+    s.start('Fetching subscription status...');
+    try {
+        const info = await client.getStatus();
+        s.stop(green('Subscription Status:'));
+
+        console.log(gray('Plan: ') + (info.plan === 'pro' ? bgCyan(' PRO ') : info.plan.toUpperCase()));
+        console.log(gray('Active: ') + (info.is_active ? green('Yes') : red('No')));
+        if (info.expires_at) console.log(gray('Expires: ') + new Date(info.expires_at).toLocaleDateString());
+
+        console.log(gray('\nLimits:'));
+        console.log(`  Models: ${info.limits.max_models === -1 ? 'Unlimited' : info.limits.max_models}`);
+        console.log(`  Training Jobs: ${info.limits.max_training_jobs}`);
+
+    } catch (e: any) {
+        s.stop(red('Failed to fetch status.'));
+        console.error(e.message);
+    }
+}

package/src/cli/handlers/tune.ts

@@ -0,0 +1,155 @@
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, bgCyan, black, gradient } from '../ui';
+import { getConfig } from '../config';
+import { Langtune, ModelClient, SubscriptionClient, FileClient, TrainingClient } from '../../index';
+
+// Handler for Langtune Fine-tuning
+export async function handleTuneFinetune(tune: Langtune, modelClient: ModelClient) {
+    let model: string | symbol = '';
+
+    const s = spinner();
+    s.start('Fetching available text models...');
+    try {
+        const models = await modelClient.list('text');
+        s.stop(`Found ${models.length} text models`);
+
+        if (models.length > 0) {
+            model = await select({
+                message: 'Select base model:',
+                options: models.map(m => ({ value: m.id, label: m.id, hint: m.owned_by }))
+            });
+        }
+    } catch (e) {
+        s.stop(yellow('Failed to fetch models. Using manual input.'));
+        model = await text({
+            message: 'Enter base model (e.g., gpt-3.5-turbo):',
+            placeholder: 'gpt-3.5-turbo',
+            validate(value) {
+                if (!value || value.length === 0) return 'Value is required!';
+            },
+        });
+    }
+
+    if (isCancel(model)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+
+    const trainFile = await text({
+        message: 'Enter path to training file:',
+        placeholder: './data.jsonl',
+        validate(value) {
+            if (!value || value.length === 0) return 'Value is required!';
+        },
+    });
+    if (isCancel(trainFile)) cancel('Operation cancelled.');
+
+    const epochs = await text({
+        message: 'Num Epochs:',
+        placeholder: '3',
+        initialValue: '3'
+    });
+    if (isCancel(epochs)) cancel('Operation cancelled.');
+
+    const track = await select({
+        message: 'Track this job on Langtrain Cloud?',
+        options: [
+            { value: 'yes', label: 'Yes', hint: 'Upload dataset and log job' },
+            { value: 'no', label: 'No', hint: 'Local only' }
+        ]
+    });
+    if (isCancel(track)) cancel('Operation cancelled.');
+
+    if (track === 'yes') {
+        const s = spinner();
+        s.start('Connecting to Cloud...');
+        try {
+            const config = getConfig();
+            if (!config.apiKey) throw new Error('API Key required. Run "login" first.');
+
+            // Check Subscription
+            const subClient = new SubscriptionClient({ apiKey: config.apiKey });
+            const sub = await subClient.getStatus();
+            if (!sub.features.includes('cloud_finetuning')) {
+                s.stop(red('Feature "cloud_finetuning" is not available on your plan.'));
+                const upgrade = await confirm({ message: 'Upgrade to Pro for cloud tracking?' });
+                if (upgrade && !isCancel(upgrade)) {
+                    console.log(bgCyan(black(' Visit https://langtrain.ai/dashboard/billing to upgrade. ')));
+                }
+                return;
+            }
+
+            const fileClient = new FileClient({ apiKey: config.apiKey });
+            const trainingClient = new TrainingClient({ apiKey: config.apiKey });
+
+            s.message('Uploading dataset...');
+            const fileResp = await fileClient.upload(trainFile as string);
+
+            s.message('Creating Job...');
+            const job = await trainingClient.createJob({
+                name: `cli-sft-${Date.now()}`,
+                base_model: model as string,
+                dataset_id: fileResp.id,
+                task: 'text',
+                hyperparameters: {
+                    n_epochs: parseInt(epochs as string)
+                }
+            });
+            s.stop(green(`Job tracked: ${job.id}`));
+        } catch (e: any) {
+            s.stop(red(`Tracking failed: ${e.message}`));
+            const cont = await confirm({ message: 'Continue with local training anyway?' });
+            if (!cont || isCancel(cont)) return;
+        }
+    }
+
+    const s2 = spinner();
+    s2.start('Starting local fine-tuning...');
+
+    try {
+        const config: any = {
+            model: model as string,
+            trainFile: trainFile as string,
+            preset: 'default', // simplified
+            epochs: parseInt(epochs as string),
+            batchSize: 1,
+            learningRate: 2e-5,
+            loraRank: 16,
+            outputDir: './output'
+        };
+
+        await tune.finetune(config);
+        s2.stop(green('Fine-tuning job started successfully!'));
+    } catch (e: any) {
+        s2.stop(red('Failed to start job.'));
+        throw e;
+    }
+}
+
+// Handler for Langtune Generation
+export async function handleTuneGenerate(tune: Langtune) {
+    const model = await text({
+        message: 'Enter model path:',
+        placeholder: './output/model',
+        initialValue: './output/model'
+    });
+    if (isCancel(model)) cancel('Operation cancelled');
+
+    const prompt = await text({
+        message: 'Enter prompt:',
+        placeholder: 'Hello world',
+    });
+    if (isCancel(prompt)) cancel('Operation cancelled');
+
+    const s = spinner();
+    s.start('Connecting to Langtrain Inference API...');
+
+    try {
+        const response = await tune.generate(model as string, { prompt: prompt as string });
+        s.stop('Generation complete');
+        intro('Response:');
+        console.log(gradient.pastel(response));
+    } catch (e: any) {
+        s.stop(red('Generation failed.'));
+        throw e;
+    }
+}

package/src/cli/handlers/vision.ts

@@ -0,0 +1,159 @@
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, bgCyan, black, gradient } from '../ui';
+import { getConfig } from '../config';
+import { Langvision, ModelClient, SubscriptionClient, FileClient, TrainingClient } from '../../index';
+
+// Handler for Langvision Fine-tuning
+export async function handleVisionFinetune(vision: Langvision, modelClient: ModelClient) {
+    let model: string | symbol = '';
+
+    const s = spinner();
+    s.start('Fetching available vision models...');
+    try {
+        const models = await modelClient.list('vision');
+        s.stop(`Found ${models.length} vision models`);
+
+        if (models.length > 0) {
+            model = await select({
+                message: 'Select base vision model:',
+                options: models.map(m => ({ value: m.id, label: m.id, hint: m.owned_by }))
+            });
+        } else {
+            model = await text({
+                message: 'Enter base vision model:',
+                placeholder: 'llava-v1.5-7b',
+                initialValue: 'llava-v1.5-7b'
+            });
+        }
+    } catch (e) {
+        s.stop(yellow('Failed to fetch models. Using manual input.'));
+        model = await text({
+            message: 'Enter base vision model:',
+            placeholder: 'llava-v1.5-7b',
+            initialValue: 'llava-v1.5-7b'
+        });
+    }
+
+    if (isCancel(model)) {
+        cancel('Operation cancelled');
+        process.exit(0);
+    }
+
+    const dataset = await text({
+        message: 'Enter dataset path:',
+        placeholder: './dataset',
+    });
+    if (isCancel(dataset)) cancel('Operation cancelled');
+
+    const epochs = await text({
+        message: 'Num Epochs:',
+        placeholder: '3',
+        initialValue: '3'
+    });
+    if (isCancel(epochs)) cancel('Operation cancelled');
+
+    const track = await select({
+        message: 'Track this job on Langtrain Cloud?',
+        options: [
+            { value: 'yes', label: 'Yes', hint: 'Upload dataset and log job' },
+            { value: 'no', label: 'No', hint: 'Local only' }
+        ]
+    });
+    if (isCancel(track)) cancel('Operation cancelled');
+
+    if (track === 'yes') {
+        const s = spinner();
+        s.start('Connecting to Cloud...');
+        try {
+            const config = getConfig();
+            if (!config.apiKey) throw new Error('API Key required. Run "login" first.');
+
+            // Check Subscription
+            const subClient = new SubscriptionClient({ apiKey: config.apiKey });
+            const sub = await subClient.getStatus();
+            if (!sub.features.includes('cloud_finetuning')) {
+                s.stop(red('Feature "cloud_finetuning" is not available on your plan.'));
+                const upgrade = await confirm({ message: 'Upgrade to Pro for cloud tracking?' });
+                if (upgrade && !isCancel(upgrade)) {
+                    console.log(bgCyan(black(' Visit https://langtrain.ai/dashboard/billing to upgrade. ')));
+                }
+                return;
+            }
+
+            const fileClient = new FileClient({ apiKey: config.apiKey });
+            const trainingClient = new TrainingClient({ apiKey: config.apiKey });
+
+            s.message('Uploading dataset...');
+            const fileResp = await fileClient.upload(dataset as string, undefined, 'fine-tune-vision');
+
+            s.message('Creating Job...');
+            const job = await trainingClient.createJob({
+                name: `cli-vision-${Date.now()}`,
+                base_model: model as string,
+                dataset_id: fileResp.id,
+                task: 'vision',
+                training_method: 'lora',
+                hyperparameters: {
+                    n_epochs: parseInt(epochs as string)
+                }
+            });
+            s.stop(green(`Job tracked: ${job.id}`));
+        } catch (e: any) {
+            s.stop(red(`Tracking failed: ${e.message}`));
+            const cont = await confirm({ message: 'Continue with local training anyway?' });
+            if (!cont || isCancel(cont)) return;
+        }
+    }
+
+    const s2 = spinner();
+    s2.start('Analyzing dataset structure...');
+    await new Promise(r => setTimeout(r, 800));
+    s2.message('Starting vision fine-tuning on Langtrain Cloud...');
+
+    try {
+        const config: any = {
+            model: model as string,
+            dataset: dataset as string,
+            epochs: parseInt(epochs as string),
+            batchSize: 1,
+            learningRate: 2e-5,
+            loraRank: 16,
+            outputDir: './vision-output'
+        };
+        await vision.finetune(config);
+        s2.stop(green('Vision fine-tuning started successfully!'));
+    } catch (e: any) {
+        s2.stop(red('Failed to start vision job.'));
+        throw e;
+    }
+}
+
+// Handler for Langvision Generation
+export async function handleVisionGenerate(vision: Langvision) {
+    const model = await text({
+        message: 'Enter model path:',
+        placeholder: './vision-output/model',
+        initialValue: './vision-output/model'
+    });
+    if (isCancel(model)) cancel('Operation cancelled');
+
+    const prompt = await text({
+        message: 'Enter prompt/image path:', // Simplified for CLI
+        placeholder: 'Describe this image...',
+    });
+    if (isCancel(prompt)) cancel('Operation cancelled');
+
+    const s = spinner();
+    s.start('Uploading image and context...');
+    await new Promise(r => setTimeout(r, 600));
+    s.message('Generating vision response...');
+
+    try {
+        const response = await vision.generate(model as string, { prompt: prompt as string });
+        s.stop('Generation complete');
+        intro('Response:');
+        console.log(gradient.pastel(response));
+    } catch (e: any) {
+        s.stop(red('Generation failed.'));
+        throw e;
+    }
+}