langtrain 0.1.18 → 0.1.19

package/src/cli/handlers/data.ts

@@ -0,0 +1,84 @@
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, gray } from '../ui';
+import { getConfig } from '../config';
+import { FileClient } from '../../index';
+import path from 'path';
+import fs from 'fs';
+
+export async function handleDataUpload(client: FileClient) {
+    const config = getConfig();
+    let workspaceId = config.workspace_id;
+
+    if (!workspaceId) {
+        // Optional: ask for workspace ID or try to infer? 
+        // For upload, workspace_id is often optional (inferred from API key's default workspace)
+        // But let's ask if user wants to specify.
+    }
+
+    const filePath = await text({
+        message: 'Path to file:',
+        placeholder: './dataset.jsonl',
+        validate(value) {
+            if (!value) return 'Required';
+            if (!fs.existsSync(value)) return 'File not found';
+        }
+    });
+
+    if (isCancel(filePath)) return;
+
+    const purpose = await select({
+        message: 'File Purpose:',
+        options: [
+            { value: 'fine-tune', label: 'Fine-tuning (JSONL)' },
+            { value: 'vision-tune', label: 'Vision Tuning (Image/Zip)' },
+            { value: 'agent-knowledge', label: 'Agent Knowledge' }
+        ]
+    });
+
+    if (isCancel(purpose)) return;
+
+    const s = spinner();
+    s.start('Uploading file...');
+
+    try {
+        const result = await client.upload(filePath as string, workspaceId, purpose as string);
+        s.stop(green('File uploaded successfully!'));
+        console.log(gray(`ID: ${result.id}`));
+        console.log(gray(`Name: ${result.filename}`));
+        console.log(gray(`Bytes: ${result.bytes}`));
+    } catch (e: any) {
+        s.stop(red(`Upload failed: ${e.message}`));
+    }
+}
+
+export async function handleDataList(client: FileClient) {
+    const config = getConfig();
+    let workspaceId = config.workspace_id;
+
+    if (!workspaceId) {
+        // Try without workspace ID (some APIs return user's files)
+        // or ask
+        workspaceId = await text({ message: 'Enter Workspace ID (optional):', initialValue: '' });
+        if (isCancel(workspaceId)) return;
+    }
+
+    const s = spinner();
+    s.start('Fetching files...');
+
+    try {
+        const files = await client.list(workspaceId as string);
+        s.stop(`Found ${files.length} files`);
+
+        if (files.length === 0) {
+            console.log(yellow('No files found.'));
+            return;
+        }
+
+        // Just list them for now, maybe select to delete later?
+        files.forEach(f => {
+            console.log(`${f.id.padEnd(30)} ${f.filename.padEnd(20)} ${f.purpose} (${f.bytes}b)`);
+        });
+
+    } catch (e: any) {
+        s.stop(red(`Failed to list files: ${e.message}`));
+    }
+}

package/src/cli/handlers/deploy.ts

@@ -0,0 +1,62 @@
+import { intro, outro, spinner, green, red, yellow, showSuccess } from '../ui';
+import { getConfig } from '../config';
+import { AgentClient, AgentCreate } from '../../index';
+
+export async function handleDeploy(client: AgentClient) {
+    intro('Deploying configuration to Langtrain Cloud...');
+
+    const config = getConfig();
+    const agents = config.agents || [];
+
+    if (agents.length === 0) {
+        intro(yellow('No agents found in langtrain.config.json'));
+        return;
+    }
+
+    // Iterate and deploy
+    for (const agentConfig of agents) {
+        const s = spinner();
+        s.start(`Deploying agent: ${agentConfig.name}...`);
+
+        try {
+            // Check if agent exists (by name? logic needed)
+            // Ideally we store ID in config after create, but for now let's just create new or try to find by name.
+            // Listing all agents is expensive if many, but safe for now.
+            const existingAgents = await client.list();
+            const existing = existingAgents.find(a => a.name === agentConfig.name);
+
+            if (existing) {
+                // Update (Note: SDK didn't expose update in my view_file, assuming create or need to add update)
+                // If update not available, we skip or warn.
+                // Let's assume we can't update yet as per SDK view.
+                // So we just skip if exists.
+                s.stop(yellow(`Agent ${agentConfig.name} already exists (ID: ${existing.id}). Skipping update (not supported yet).`));
+            } else {
+                // Create
+                const payload: AgentCreate = {
+                    workspace_id: config.workspace_id || (existingAgents[0]?.workspace_id) || '', // Need a way to get workspace!
+                    name: agentConfig.name,
+                    description: agentConfig.description,
+                    config: agentConfig.config
+                };
+
+                // Fallback for workspace_id
+                if (!payload.workspace_id) {
+                    // Try to get from first agent or error
+                    // Realistically, user needs to set workspace_id in config or we infer from API key scope.
+                    // Let's warn.
+                    s.stop(red(`Failed: Workspace ID missing in config for ${agentConfig.name}`));
+                    continue;
+                }
+
+                await client.create(payload);
+                s.stop(green(`Agent ${agentConfig.name} deployed successfully!`));
+            }
+
+        } catch (e: any) {
+            s.stop(red(`Failed to deploy ${agentConfig.name}: ${e.message}`));
+        }
+    }
+
+    showSuccess('Deployment complete.');
+}

package/src/cli/handlers/dev.ts

@@ -0,0 +1,42 @@
+import { intro, outro, spinner, green, red, yellow, showInfo, gray } from '../ui';
+import { AgentClient } from '../../index';
+import { handleDeploy } from './deploy';
+import fs from 'fs';
+import path from 'path';
+
+export async function handleDev(client: AgentClient) {
+    intro('Starting Langtrain Development Server...');
+
+    const configPath = path.join(process.cwd(), 'langtrain.config.json');
+    if (!fs.existsSync(configPath)) {
+        intro(red('langtrain.config.json not found. Run "lt init" first.'));
+        return;
+    }
+
+    console.log(gray(`Watching ${configPath} for changes...`));
+
+    let isDeploying = false;
+
+    // Initial Deploy
+    await handleDeploy(client);
+
+    fs.watch(configPath, async (eventType) => {
+        if (eventType === 'change' && !isDeploying) {
+            isDeploying = true;
+            console.log(yellow('Configuration changed. Redeploying...'));
+            // Wait a bit for file write to complete
+            await new Promise(r => setTimeout(r, 500));
+            try {
+                await handleDeploy(client);
+            } catch (e: any) {
+                console.error(red(`Deploy failed: ${e.message}`));
+            } finally {
+                isDeploying = false;
+                console.log(gray(`Watching ${configPath}...`));
+            }
+        }
+    });
+
+    // Keep process alive
+    await new Promise(() => { });
+}

package/src/cli/handlers/doctor.ts

@@ -0,0 +1,54 @@
+import { intro, outro, showSuccess, showError, showWarning, showInfo, spinner, colors } from '../ui';
+import { getConfig } from '../config';
+import { getSubscription } from '../auth';
+import os from 'os';
+
+export async function handleDoctor() {
+    intro('Running Langtrain Doctor...');
+
+    const s = spinner();
+    let issues = 0;
+
+    // 1. Check Node Environment
+    s.start('Checking Node.js environment...');
+    const nodeVersion = process.version;
+    const platform = os.platform();
+    const arch = os.arch();
+
+    if (parseInt(nodeVersion.replace('v', '').split('.')[0]) < 18) {
+        s.stop(colors.red(`Node.js version ${nodeVersion} is outdated. Please upgrade to v18+.`));
+        issues++;
+    } else {
+        s.stop(`Node.js ${nodeVersion} (${platform} ${arch})`);
+    }
+
+    // 2. Check Configuration
+    s.start('Checking configuration...');
+    const config = getConfig();
+    if (!config.apiKey) {
+        s.stop(colors.yellow('API Key is missing. Run `langtrain login` or set LANGTRAIN_API_KEY.'));
+        issues++;
+    } else {
+        s.stop('Configuration found.');
+
+        // 3. Check API Connectivity
+        s.start('Checking API connectivity...');
+        try {
+            const plan = await getSubscription(config.apiKey);
+            s.stop(`Connected to Langtrain Cloud (Plan: ${colors.green(plan?.plan || 'unknown')})`);
+        } catch (e: any) {
+            s.stop(colors.red(`Failed to connect to Langtrain Cloud: ${e.message}`));
+            issues++;
+        }
+    }
+
+    console.log(''); // Spacer
+
+    if (issues === 0) {
+        showSuccess('Your Langtrain environment is healthy! Ready to build.');
+    } else {
+        showWarning(`Found ${issues} issue(s). Please resolve them for the best experience.`);
+    }
+
+    outro('Doctor check complete.');
+}

package/src/cli/handlers/init.ts

@@ -0,0 +1,104 @@
+import path from 'path';
+import fs from 'fs';
+import { text, confirm, select, isCancel, cancel, intro, outro, showSuccess, showInfo, spinner, colors } from '../ui';
+import { getConfig } from '../config';
+import { handleLogin } from '../auth';
+
+export async function handleInit() {
+    intro('Initializing new Langtrain project...');
+
+    const cwd = process.cwd();
+
+    // 1. Check if already initialized
+    if (fs.existsSync(path.join(cwd, 'langtrain.config.json'))) {
+        showInfo('langtrain.config.json already exists in this directory.');
+        const overwrite = await confirm({
+            message: 'Do you want to re-initialize and overwrite the config?',
+            initialValue: false
+        });
+
+        if (isCancel(overwrite) || !overwrite) {
+            outro('Initialization cancelled.');
+            return;
+        }
+    }
+
+    // 2. Ask for Project Details
+    const projectName = await text({
+        message: 'What is the name of your project?',
+        placeholder: 'my-ai-app',
+        initialValue: path.basename(cwd),
+        validate(value) {
+            if (!value || value.length === 0) return 'Project name is required!';
+        }
+    });
+
+    if (isCancel(projectName)) {
+        cancel('Operation cancelled.');
+        return;
+    }
+
+    let config = getConfig();
+    let apiKey = config.apiKey;
+
+    if (apiKey) {
+        showSuccess('Found existing Langtrain credentials.');
+    } else {
+        const shouldLogin = await confirm({
+            message: 'You are not logged in. Do you want to log in now?',
+            initialValue: true
+        });
+
+        if (isCancel(shouldLogin)) {
+            cancel('Operation cancelled.');
+            return;
+        }
+
+        if (shouldLogin) {
+            await handleLogin();
+            config = getConfig(); // Reload config
+            apiKey = config.apiKey;
+        } else {
+            apiKey = await text({
+                message: 'Enter your Langtrain API Key (optional for local dev):',
+                placeholder: 'lt_sk_...',
+                initialValue: ''
+            }) as string;
+
+            if (isCancel(apiKey)) {
+                cancel('Operation cancelled.');
+                return;
+            }
+        }
+    }
+
+    // 3. Create Config File
+    const s = spinner();
+    s.start('Creating configuration...');
+
+    const configContent = {
+        name: projectName,
+        apiKey: apiKey || undefined,
+        environment: 'development',
+        agents: [
+            {
+                name: 'support-bot',
+                description: 'A helpful customer support assistant',
+                config: {
+                    model: 'llama-3-8b',
+                    system_prompt: 'You are a helpful customer support assistant.',
+                    temperature: 0.7
+                }
+            }
+        ]
+    };
+
+    fs.writeFileSync(path.join(cwd, 'langtrain.config.json'), JSON.stringify(configContent, null, 2));
+
+    showSuccess('Project initialized successfully!');
+    console.log(colors.dim('\nNext steps:'));
+    console.log(`  1. Run ${colors.cyan('lt deploy')} to push your agent to the cloud.`);
+    console.log(`  2. Run ${colors.cyan('lt dev')} to start the local development loop.`);
+
+    outro('Happy coding!');
+}

package/src/cli/handlers/tune.ts

@@ -1,4 +1,4 @@
-import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, bgCyan, black, gradient } from '../ui';
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, bgCyan, black, gradient, gray } from '../ui';
 import { getConfig } from '../config';
 import { Langtune, ModelClient, SubscriptionClient, FileClient, TrainingClient } from '../../index';
 
@@ -153,3 +153,105 @@ export async function handleTuneGenerate(tune: Langtune) {
         throw e;
     }
 }
+
+export async function handleTuneList(trainingClient: TrainingClient) {
+    const s = spinner();
+    s.start('Fetching fine-tuning jobs...');
+
+    // We need workspace ID, usually from config or first agent?
+    // For now, let's just ask or list from all available if API supports it (it requires workspace_id)
+    // Let's assume user knows it or we can find it.
+    // Simplified: Just ask for Workspace ID if not in config (we don't save it yet)
+    // BETTER: Get it from an existing agent or config.
+    const config = getConfig();
+    let workspaceId = config.workspace_id;
+
+    if (!workspaceId) {
+        s.stop(yellow('Workspace ID required to list jobs.'));
+        workspaceId = await text({ message: 'Enter Workspace ID:' });
+        if (isCancel(workspaceId)) return;
+    }
+
+    try {
+        const jobs = await trainingClient.listJobs(workspaceId as string);
+        s.stop(`Found ${jobs.data.length} jobs`);
+
+        if (jobs.data.length === 0) {
+            console.log(yellow('No jobs found.'));
+            return;
+        }
+
+        const selectedJob = await select({
+            message: 'Select a job to view details:',
+            options: jobs.data.map(j => ({
+                value: j.id,
+                label: `${j.name || j.id} (${j.status})`,
+                hint: `Created: ${new Date(j.created_at).toLocaleDateString()}`
+            }))
+        });
+
+        if (isCancel(selectedJob)) return;
+
+        await handleTuneStatus(trainingClient, selectedJob as string);
+
+    } catch (e: any) {
+        s.stop(red(`Failed to list jobs: ${e.message}`));
+    }
+}
+
+export async function handleTuneStatus(trainingClient: TrainingClient, jobId?: string) {
+    let id = jobId;
+    if (!id) {
+        id = await text({ message: 'Enter Job ID:' }) as string;
+        if (isCancel(id)) return;
+    }
+
+    const s = spinner();
+    s.start(`Fetching status for ${id}...`);
+
+    try {
+        const job = await trainingClient.getJob(id);
+        s.stop(`Job Status: ${job.status.toUpperCase()}`);
+
+        console.log(gray('------------------------------------------------'));
+        console.log(`${bgCyan(black(' Job Details '))}`);
+        console.log(`ID:        ${job.id}`);
+        console.log(`Name:      ${job.name}`);
+        console.log(`Status:    ${job.status === 'succeeded' ? green(job.status) : job.status}`);
+        console.log(`Model:     ${job.base_model}`);
+        console.log(`Progress:  ${job.progress || 0}%`);
+        if (job.error_message) console.log(red(`Error:     ${job.error_message}`));
+        console.log(gray('------------------------------------------------'));
+
+        if (job.status === 'running' || job.status === 'queued') {
+            const action = await select({
+                message: 'Action:',
+                options: [
+                    { value: 'refresh', label: 'Refresh Status' },
+                    { value: 'cancel', label: 'Cancel Job' },
+                    { value: 'back', label: 'Back' }
+                ]
+            });
+
+            if (action === 'refresh') await handleTuneStatus(trainingClient, id);
+            if (action === 'cancel') await handleTuneCancel(trainingClient, id);
+        }
+
+    } catch (e: any) {
+        s.stop(red(`Failed to get job status: ${e.message}`));
+    }
+}
+
+export async function handleTuneCancel(trainingClient: TrainingClient, jobId: string) {
+    const confirmCancel = await confirm({ message: 'Are you sure you want to cancel this job?' });
+    if (!confirmCancel || isCancel(confirmCancel)) return;
+
+    const s = spinner();
+    s.start('Canceling job...');
+    try {
+        await trainingClient.cancelJob(jobId);
+        s.stop(green('Job canceled successfully.'));
+    } catch (e: any) {
+        s.stop(red(`Failed to cancel job: ${e.message}`));
+    }
+}

package/src/cli/index.ts

@@ -1,7 +1,7 @@
 #!/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 { select, isCancel, outro, intro, colors } 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';
@@ -9,12 +9,17 @@ import { getConfig } from './config';
 
 // Handlers
 import { handleSubscriptionStatus } from './handlers/subscription';
-import { handleTuneFinetune, handleTuneGenerate } from './handlers/tune';
+import { handleTuneFinetune, handleTuneGenerate, handleTuneList } from './handlers/tune';
 import { handleVisionFinetune, handleVisionGenerate } from './handlers/vision';
 import { handleAgentCreate, handleAgentDelete, handleAgentList } from './handlers/agent';
+import { handleInit } from './handlers/init';
+import { handleDoctor } from './handlers/doctor';
+import { handleDataUpload } from './handlers/data';
+import { handleDeploy } from './handlers/deploy';
+import { handleDev } from './handlers/dev';
 
 // Clients
-import { SubscriptionInfo, Langvision, Langtune, AgentClient, ModelClient } from '../index';
+import { SubscriptionInfo, Langvision, Langtune, AgentClient, ModelClient, FileClient, TrainingClient } from '../index';
 import packageJson from '../../package.json';
 
 export async function main() {
@@ -26,6 +31,29 @@ export async function main() {
         .description(packageJson.description || 'Langtrain CLI for AI Model Fine-tuning and Generation')
         .version(version);
 
+    // Register standalone commands
+    program.command('init')
+        .description('Initialize a new Langtrain project')
+        .action(handleInit);
+
+    program.command('deploy')
+        .description('Deploy configuration to Langtrain Cloud')
+        .action(async () => {
+            const config = getConfig();
+            const apiKey = config.apiKey || '';
+            const client = new AgentClient({ apiKey, baseUrl: config.baseUrl });
+            await handleDeploy(client);
+        });
+
+    program.command('dev')
+        .description('Start local development server (Watch Mode)')
+        .action(async () => {
+            const config = getConfig();
+            const apiKey = config.apiKey || '';
+            const client = new AgentClient({ apiKey, baseUrl: config.baseUrl });
+            await handleDev(client);
+        });
+
     program.action(async () => {
         showBanner(version);
 
@@ -60,7 +88,8 @@ export async function main() {
             vision: new Langvision({ apiKey }),
             tune: new Langtune({ apiKey }),
             agent: new AgentClient({ apiKey, baseUrl: config.baseUrl }),
-            model: new ModelClient({ apiKey, baseUrl: config.baseUrl })
+            model: new ModelClient({ apiKey, baseUrl: config.baseUrl }),
+            train: new TrainingClient({ apiKey, baseUrl: config.baseUrl })
         };
 
         // 3. Navigation Loop
@@ -114,25 +143,32 @@ export async function main() {
                             vision: new Langvision({ apiKey }),
                             tune: new Langtune({ apiKey }),
                             agent: new AgentClient({ apiKey, baseUrl: config.baseUrl }),
-                            model: new ModelClient({ apiKey, baseUrl: config.baseUrl })
+                            model: new ModelClient({ apiKey, baseUrl: config.baseUrl }),
+                            train: new TrainingClient({ apiKey, baseUrl: config.baseUrl })
                         };
                         try { plan = await getSubscription(apiKey); } catch { }
                         break;
                     case 'status': await handleSubscriptionStatus(); break;
+                    case 'init': await handleInit(); break;
+                    case 'deploy': await handleDeploy(clients.agent); break;
+                    case 'dev': await handleDev(clients.agent); break;
+                    case 'doctor': await handleDoctor(); break;
                     case 'tune-finetune': await handleTuneFinetune(clients.tune, clients.model); break;
+                    case 'tune-list': await handleTuneList(clients.train); 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;
+                    case 'data-upload': await handleDataUpload(new FileClient({ apiKey })); break;
                 }
 
                 // After action, where do we go? 
                 // Stay in current state (sub-menu) is usually preferred.
 
             } catch (error: any) {
-                outro(red(`Error: ${error.message}`));
+                outro(colors.red(`Error: ${error.message}`));
             }
         }
     });

package/src/cli/menu.ts

@@ -21,6 +21,10 @@ export function getMenu(state: MenuState, plan: SubscriptionInfo | null, isAuthe
                 { 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: 'init', label: 'Initialize Project', hint: 'Scaffold new Langtrain app' },
+                { value: 'deploy', label: 'Deploy', hint: 'Push config to Cloud' },
+                { value: 'dev', label: 'Start Dev Server', hint: 'Watch mode' },
+                { value: 'doctor', label: 'Doctor', hint: 'Check environment health' },
                 { value: 'nav-settings', label: 'Settings', hint: 'Subscription & Auth' }
             ];
 
@@ -37,7 +41,7 @@ export function getMenu(state: MenuState, plan: SubscriptionInfo | null, isAuthe
 
         case 'agents':
             return [
-                { value: 'agent-list', label: 'List & Run Agents', hint: 'View active agents' },
+                { value: 'agent-list', label: 'List & Run Agents', hint: 'Chat with 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' }
@@ -46,7 +50,9 @@ export function getMenu(state: MenuState, plan: SubscriptionInfo | null, isAuthe
         case 'text':
             return [
                 { value: 'tune-finetune', label: 'Fine-tune Text Model', hint: 'Create custom LLM' },
+                { value: 'tune-list', label: 'List Jobs', hint: 'Check training status' },
                 { value: 'tune-generate', label: 'Generate Text', hint: 'Test your models' },
+                { value: 'data-upload', label: 'Upload Dataset', hint: 'Upload JSONL for training' },
                 { value: 'back', label: '← Back to Main Menu' }
             ];
 

package/src/cli/ui.ts

@@ -1,11 +1,10 @@
-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 { text, select, confirm, password, isCancel, cancel, note } from '@clack/prompts';
+import { bgCyan, black, red, green, yellow, gray, cyan, bold, dim, blue } from 'kleur/colors';
 import gradient from 'gradient-string';
 
+// Re-export specific prompts to keep imports clean in other files
+export { text, select, confirm, password, isCancel, cancel, note };
+
 export function showBanner(version: string) {
     console.clear();
     const banner = `
@@ -47,4 +46,22 @@ 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 };
+export function showWarning(message: string) {
+    console.log(yellow(`⚠ Warning: ${message}`));
+}
+
+export function showInfo(message: string) {
+    console.log(blue(`ℹ ${message}`));
+}
+
+export function showDim(message: string) {
+    console.log(dim(message));
+}
+
+// Re-export for backward compatibility
+export { bgCyan, black, red, green, yellow, gray, cyan, bold, dim, blue, gradient };
+
+export const colors = {
+    bgCyan, black, red, green, yellow, gray, cyan, bold, dim, blue
+};
+