langtrain 0.1.18 → 0.1.20

package/src/cli/handlers/agent.ts

@@ -146,12 +146,31 @@ export async function handleAgentList(client: AgentClient) {
     await handleAgentRun(client, agentId as string, agents.find(a => a.id === agentId)?.name || 'Agent');
 }
 
-async function handleAgentRun(client: AgentClient, agentId: string, agentName: string) {
+export async function handleAgentRun(client: AgentClient, agentId: string, agentName: string, initialMessage?: string) {
     intro(bgCyan(black(` Chatting with ${agentName} `)));
     console.log(gray('Type "exit" to quit conversation.'));
 
     let conversationId: string | undefined = undefined;
 
+    // Send initial message if provided
+    if (initialMessage) {
+        const s = spinner();
+        s.start('Agent is analyzing...');
+        try {
+            const result = await client.execute(agentId, { prompt: initialMessage }, [], conversationId);
+            s.stop();
+            if ((result.output as any)?.response) {
+                console.log(gradient.pastel(`Agent: ${(result.output as any).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);
+        }
+    }
+
     while (true) {
         const input = await text({
             message: 'You:',
@@ -168,8 +187,8 @@ async function handleAgentRun(client: AgentClient, agentId: string, agentName: s
             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}`));
+            if ((result.output as any)?.response) {
+                console.log(gradient.pastel(`Agent: ${(result.output as any).response}`));
             } else {
                 console.log(gradient.pastel(`Agent: ${JSON.stringify(result.output)}`));
             }

package/src/cli/handlers/data.ts

@@ -0,0 +1,207 @@
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, gray } from '../ui';
+import { getConfig } from '../config';
+import { FileClient, AgentClient, GuardrailClient } from '../../index';
+import { handleAgentRun } from './agent';
+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;
+        }
+
+        const file = await select({
+            message: 'Select file to analyze (or cancel to exit):',
+            options: files.map(f => ({ value: f.id, label: `${f.filename} (${formatBytes(f.bytes)})` }))
+        });
+
+        if (isCancel(file)) return;
+
+        await handleDataAnalyze(client, file as string);
+
+    } catch (e: any) {
+        s.stop(red(`Failed to list files: ${e.message}`));
+    }
+}
+
+export async function handleDataAnalyze(client: FileClient, fileId: string) {
+    const config = getConfig();
+    const s2 = spinner();
+    s2.start('Connecting to Data Analyst...');
+
+    try {
+        const agentClient = new AgentClient({ apiKey: config.apiKey || '', baseUrl: config.baseUrl });
+        const agents = await agentClient.list();
+        // Check name (name is optional in type but we know it exists for system agent)
+        let analyst = agents.find(a => a.name && a.name === "Langtrain Data Analyst");
+
+        if (!analyst) {
+            s2.stop(yellow('Data Analyst agent (System) not found. Please contact admin to provision it.'));
+            return;
+        }
+
+        s2.stop(green('Connected to Data Analyst.'));
+
+        console.log(gray(`\nAnalyzing dataset ${fileId}...\n`));
+
+        await handleAgentRun(agentClient, analyst.id, analyst.name, `Please analyze the dataset with ID: ${fileId}`);
+
+    } catch (e: any) {
+        s2.stop(red(`Failed to connect: ${e.message}`));
+    }
+}
+
+export async function handleDataRefine(client: FileClient, fileId?: string) {
+    const config = getConfig();
+    const gClient = new GuardrailClient({ apiKey: config.apiKey || '', baseUrl: config.baseUrl });
+
+    // 0. Select File if not provided
+    if (!fileId) {
+        const s = spinner();
+        s.start('Fetching files...');
+        try {
+            // Need workspace ID logic similar to List?
+            // client.list takes workspaceId.
+            const wId = config.workspace_id || '';
+            const files = await client.list(wId);
+            s.stop(`Found ${files.length} files`);
+
+            if (files.length === 0) {
+                console.log(yellow('No files found. Upload one first.'));
+                return;
+            }
+
+            const selection = await select({
+                message: 'Select file to refine:',
+                options: files.map(f => ({ value: f.id, label: `${f.filename} (${formatBytes(f.bytes)})` }))
+            });
+
+            if (isCancel(selection)) return;
+            fileId = selection as string;
+
+        } catch (e: any) {
+            s.stop(red(`Failed to fetch files: ${e.message}`));
+            return;
+        }
+    }
+
+    // 1. Select Guardrail
+    const s = spinner();
+    s.start('Fetching guardrails...');
+    let guardId = "";
+    try {
+        const guards = await gClient.list();
+        s.stop(`Found ${guards.length} guardrails`);
+
+        if (guards.length === 0) {
+            console.log(yellow('No guardrails found. Please create one first using "lt guardrails create".'));
+            return;
+        }
+
+        const selection = await select({
+            message: 'Select a Guardrail to apply:',
+            options: guards.map((g: any) => ({
+                value: g.id,
+                label: g.name,
+                hint: g.description
+            }))
+        });
+
+        if (isCancel(selection)) return;
+        guardId = selection as string;
+
+    } catch (e: any) {
+        s.stop(red(`Failed to fetch guardrails: ${e.message}`));
+        return;
+    }
+
+    // 2. Apply
+    const s2 = spinner();
+    s2.start('Applying guardrail (filtering dataset)...');
+
+    try {
+        const result = await gClient.apply(fileId, guardId);
+        s2.stop(green('Dataset refined successfully!'));
+
+        console.log(gray('Stats:'));
+        console.log(`Original Rows: ${result.original_rows}`);
+        console.log(`Filtered Rows: ${result.filtered_rows}`);
+        console.log(red(`Removed: ${result.removed_rows} rows`));
+        console.log(green(`New Dataset ID: ${result.new_dataset_id}`));
+
+    } catch (e: any) {
+        s2.stop(red(`Failed to refine dataset: ${e.message}`));
+    }
+}
+
+function formatBytes(bytes: number, decimals = 2) {
+    if (!+bytes) return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}

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/env.ts

@@ -0,0 +1,89 @@
+import { intro, outro, spinner, green, red, yellow, showInfo, gray, showSuccess } from '../ui';
+import { SecretClient } from '../../index';
+import { text, confirm, select, isCancel, cancel } from '../ui';
+import { getConfig } from '../config';
+
+export async function handleEnvList(client: SecretClient) {
+    const s = spinner();
+    s.start('Fetching secrets...');
+    const config = getConfig();
+    try {
+        const secrets = await client.list(config.workspace_id);
+        s.stop(`Found ${secrets.length} secrets`);
+
+        if (secrets.length === 0) {
+            console.log(gray('No secrets found. Use "lt env set" to add one.'));
+            return;
+        }
+
+        console.log(gray('------------------------------------------------'));
+        secrets.forEach(sec => {
+            console.log(`${sec.key.padEnd(30)} ${gray('******')}`);
+        });
+        console.log(gray('------------------------------------------------'));
+
+    } catch (e: any) {
+        s.stop(red(`Failed to list secrets: ${e.message}`));
+    }
+}
+
+export async function handleEnvSet(client: SecretClient, keyVal?: string) {
+    let key = '';
+    let value = '';
+
+    if (keyVal && keyVal.includes('=')) {
+        const parts = keyVal.split('=');
+        key = parts[0];
+        value = parts.slice(1).join('=');
+    } else {
+        key = await text({ message: 'Secret Key:', placeholder: 'OPENAI_API_KEY' }) as string;
+        if (isCancel(key)) return;
+
+        value = await text({ message: 'Secret Value:', placeholder: 'sk-...' }) as string;
+        if (isCancel(value)) return;
+    }
+
+    const s = spinner();
+    s.start(`Setting ${key}...`);
+    const config = getConfig();
+
+    try {
+        await client.set(key, value, config.workspace_id);
+        s.stop(green(`Secret ${key} set successfully.`));
+    } catch (e: any) {
+        s.stop(red(`Failed to set secret: ${e.message}`));
+    }
+}
+
+// Interactive menu for env
+export async function handleEnvMenu(client: SecretClient) {
+    const action = await select({
+        message: 'Manage Secrets',
+        options: [
+            { value: 'list', label: 'List Secrets' },
+            { value: 'set', label: 'Set Secret' },
+            { value: 'remove', label: 'Remove Secret' },
+            { value: 'back', label: 'Back' }
+        ]
+    });
+
+    if (isCancel(action) || action === 'back') return;
+
+    if (action === 'list') await handleEnvList(client);
+    if (action === 'set') await handleEnvSet(client);
+    if (action === 'remove') {
+        const key = await text({ message: 'Key to remove:' });
+        if (!isCancel(key)) {
+            const s = spinner();
+            s.start('Removing...');
+            try {
+                // need workspace_id
+                const config = getConfig();
+                await client.delete(key as string, config.workspace_id);
+                s.stop(green('Removed.'));
+            } catch (e: any) {
+                s.stop(red(`Failed: ${e.message}`));
+            }
+        }
+    }
+}

package/src/cli/handlers/guardrails.ts

@@ -0,0 +1,100 @@
+import { text, select, confirm, isCancel, cancel, spinner, intro, red, green, yellow, gray } from '../ui';
+import { getConfig } from '../config';
+import { GuardrailClient } from '../../index';
+
+export async function handleGuardrailList(client: any) { // using any to match index signature, but we instantiate specific client inside
+    const config = getConfig();
+    const gClient = new GuardrailClient({ apiKey: config.apiKey || '', baseUrl: config.baseUrl });
+
+    const s = spinner();
+    s.start('Fetching guardrails...');
+
+    try {
+        const guards = await gClient.list();
+        s.stop(`Found ${guards.length} guardrails`);
+
+        if (guards.length === 0) {
+            console.log(yellow('No guardrails found. Create one with "lt guardrails create".'));
+            return;
+        }
+
+        guards.forEach((g: any) => {
+            console.log(green(`• ${g.name}`) + gray(` (ID: ${g.id})`));
+            if (g.description) console.log(gray(`  ${g.description}`));
+            console.log(gray(`  Config: PII=${g.config.pii_enabled}, MinLen=${g.config.min_length}`));
+            console.log('');
+        });
+
+    } catch (e: any) {
+        s.stop(red(`Failed to list guardrails: ${e.message}`));
+    }
+}
+
+export async function handleGuardrailCreate(client: any) {
+    const config = getConfig();
+    const gClient = new GuardrailClient({ apiKey: config.apiKey || '', baseUrl: config.baseUrl });
+
+    intro('Create a new Data Guardrail');
+
+    const name = await text({
+        message: 'Guardrail Name:',
+        placeholder: 'e.g. Strict Safety Policy',
+        validate(value) {
+            if (!value) return 'Name is required';
+        }
+    });
+    if (isCancel(name)) return;
+
+    const description = await text({
+        message: 'Description (optional):',
+        placeholder: 'Filters PII and short text',
+    });
+    if (isCancel(description)) return;
+
+    // Interactive Config
+    const minLen = await text({
+        message: 'Minimum Text Length (0 for no limit):',
+        initialValue: '0',
+        validate(value) {
+            if (isNaN(Number(value))) return 'Must be a number';
+        }
+    });
+    if (isCancel(minLen)) return;
+
+    const enablePii = await confirm({
+        message: 'Enable PII Filtering (Email/Phone)?',
+        initialValue: false
+    });
+    if (isCancel(enablePii)) return;
+
+    const patterns = await text({
+        message: 'Regex Patterns to Block (comma separated, optional):',
+        placeholder: 'e.g. bad_word, another_one',
+    });
+    if (isCancel(patterns)) return;
+
+    const s = spinner();
+    s.start('Creating guardrail...');
+
+    try {
+        const regexList = (patterns as string).split(',').map(p => p.trim()).filter(p => p.length > 0);
+
+        const payload = {
+            name,
+            description,
+            config: {
+                min_length: Number(minLen),
+                pii_enabled: enablePii,
+                regex_patterns: regexList,
+                profanity_enabled: false
+            }
+        };
+
+        const result = await gClient.create(payload);
+        s.stop(green(`Guardrail "${result.name}" created successfully!`));
+        console.log(gray(`ID: ${result.id}`));
+
+    } catch (e: any) {
+        s.stop(red(`Failed to create guardrail: ${e.message}`));
+    }
+}