luxlabs 1.0.0

package/commands/interface.js

@@ -0,0 +1,125 @@
+/**
+ * Interface (App) Commands
+ *
+ * This is the main entry point for interface/app commands.
+ * The implementation is split into modules under ./interface/:
+ *
+ * - git-utils.js    - Git command helpers (runGitCommand, cloneRepoWithRetry)
+ * - boilerplate.js  - Template generation (getBoilerplateFiles, writeBoilerplateFiles)
+ * - init.js         - Interface initialization (initInterface, pushBoilerplateTemplate)
+ * - path.js         - Path resolution (getInterfacePath)
+ */
+
+const chalk = require('chalk');
+
+// Import from modular files
+const { initInterface } = require('./interface/init');
+const { getInterfacePath } = require('./interface/path');
+
+/**
+ * Deploy interface to production
+ */
+async function deployInterface(options) {
+  const { deploy } = require('./deploy');
+  await deploy(options);
+}
+
+/**
+ * List all interfaces
+ */
+async function listInterfaces(options) {
+  const { list } = require('./list');
+  await list(options);
+}
+
+/**
+ * View interface logs
+ */
+async function viewLogs(options) {
+  const { logs } = require('./logs');
+  await logs(options);
+}
+
+/**
+ * Parse command options from args array
+ */
+function parseOptions(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const value = args[i + 1];
+      options[key] = value || true;
+      if (value && !value.startsWith('--')) {
+        i++; // Skip next arg since we used it as a value
+      }
+    } else if (arg.startsWith('-')) {
+      const key = arg.slice(1);
+      const value = args[i + 1];
+      options[key] = value || true;
+      if (value && !value.startsWith('-')) {
+        i++;
+      }
+    }
+  }
+  return options;
+}
+
+/**
+ * Show help for interface commands
+ */
+function showHelp() {
+  console.log(chalk.cyan('\nLux Interface Commands:\n'));
+  console.log(chalk.white('  lux interface create --name <name>') + chalk.dim(' (or lux i create)'));
+  console.log(chalk.dim('    Create new interface'));
+  console.log(chalk.dim('    Required: --name <interface-name>'));
+  console.log(chalk.dim('    Optional: --description <desc>\n'));
+  console.log(chalk.white('  lux interface init') + chalk.dim(' (alias for create)\n'));
+  console.log(chalk.white('  lux interface list') + chalk.dim(' (or lux i list)'));
+  console.log(chalk.dim('    List all interfaces\n'));
+  console.log(chalk.white('  lux interface path <name-or-id>'));
+  console.log(chalk.dim('    Get local repo path for an interface\n'));
+  console.log(chalk.white('  lux interface deploy') + chalk.dim(' (or lux i deploy)'));
+  console.log(chalk.dim('    Deploy interface to production\n'));
+  console.log(chalk.white('  lux interface logs') + chalk.dim(' (or lux i logs)'));
+  console.log(chalk.dim('    View interface logs\n'));
+}
+
+/**
+ * Handle interface commands
+ */
+async function handleInterface(subcommand, args) {
+  if (!subcommand || subcommand === 'help') {
+    showHelp();
+    return;
+  }
+
+  switch (subcommand) {
+    case 'init':
+    case 'create':
+      await initInterface(parseOptions(args));
+      break;
+    case 'deploy':
+      await deployInterface(parseOptions(args));
+      break;
+    case 'list':
+    case 'ls':
+      await listInterfaces(parseOptions(args));
+      break;
+    case 'logs':
+      await viewLogs(parseOptions(args));
+      break;
+    case 'path':
+      await getInterfacePath(args[0]);
+      break;
+    default:
+      console.log(chalk.red(`Unknown subcommand: ${subcommand}`));
+      showHelp();
+      process.exit(1);
+  }
+}
+
+module.exports = {
+  handleInterface,
+};

package/commands/knowledge.js

@@ -0,0 +1,339 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const FormData = require('form-data');
+const {
+  getApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+} = require('../lib/config');
+const {
+  error,
+  success,
+  info,
+  formatJson,
+  formatTable,
+  requireArgs,
+} = require('../lib/helpers');
+
+async function handleKnowledge(args) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const command = args[0];
+
+  if (!command) {
+    console.log(`
+${chalk.bold('Usage:')} lux knowledge <command> [args]
+
+${chalk.bold('Document Commands:')}
+  list                              List all documents and folders
+  get <document-id>                 Get document details and content
+  url <document-id>                 Get public URL for a document
+  upload <file-path> [folder-id]    Upload a file to knowledge base
+  delete <document-id>              Delete a document
+
+${chalk.bold('Folder Commands:')}
+  folders list                      List all folders
+  folders create <name> [parent-id] Create a new folder
+  folders delete <folder-id>        Delete a folder
+
+${chalk.bold('Examples:')}
+  lux knowledge list
+  lux knowledge get doc_123abc
+  lux knowledge upload ./data.json
+  lux knowledge upload ./image.png folder_xyz
+  lux knowledge folders create "Product Docs"
+`);
+    process.exit(0);
+  }
+
+  const apiUrl = getApiUrl();
+
+  try {
+    // ============ DOCUMENT COMMANDS ============
+    if (command === 'list') {
+      info('Loading knowledge base...');
+
+      const [foldersRes, docsRes] = await Promise.all([
+        axios.get(`${apiUrl}/api/knowledge/folders`, {
+          headers: getAuthHeaders(),
+        }),
+        axios.get(`${apiUrl}/api/knowledge/documents`, {
+          headers: getAuthHeaders(),
+        }),
+      ]);
+
+      const folders = foldersRes.data.folders || [];
+      const documents = docsRes.data.documents || [];
+
+      if (folders.length === 0 && documents.length === 0) {
+        console.log('\n(No knowledge items found)\n');
+        return;
+      }
+
+      if (folders.length > 0) {
+        console.log(`\n${chalk.bold('Folders')} (${folders.length}):\n`);
+        formatTable(folders.map(f => ({
+          id: f.id,
+          name: f.name,
+          path: f.path,
+        })));
+      }
+
+      if (documents.length > 0) {
+        console.log(`\n${chalk.bold('Documents')} (${documents.length}):\n`);
+        formatTable(documents.map(d => ({
+          id: d.id,
+          name: d.name,
+          type: d.document_type || d.file_type || 'unknown',
+          size: formatFileSize(d.file_size),
+          folder: d.folder_id || '(root)',
+        })));
+      }
+      console.log('');
+    }
+
+    else if (command === 'get') {
+      requireArgs(args.slice(1), 1, 'lux knowledge get <document-id>');
+      const docId = args[1];
+
+      info(`Loading document: ${docId}`);
+      const { data } = await axios.get(
+        `${apiUrl}/api/knowledge/documents/${docId}`,
+        { headers: getAuthHeaders() }
+      );
+
+      const doc = data.document;
+      console.log(`\n${chalk.bold('Document Details:')}`);
+      console.log(`  ID: ${doc.id}`);
+      console.log(`  Name: ${doc.name}`);
+      console.log(`  Type: ${doc.document_type || doc.file_type || 'unknown'}`);
+      console.log(`  Size: ${formatFileSize(doc.file_size)}`);
+      console.log(`  Folder: ${doc.folder_id || '(root)'}`);
+
+      if (doc.public_url) {
+        console.log(`  URL: ${doc.public_url}`);
+      }
+
+      if (doc.image_width && doc.image_height) {
+        console.log(`  Dimensions: ${doc.image_width}x${doc.image_height}`);
+        console.log(`  Est. Tokens: ${doc.estimated_tokens || 'N/A'}`);
+      }
+
+      if (doc.content) {
+        console.log(`\n${chalk.bold('Content:')}`);
+        console.log(doc.content.substring(0, 2000));
+        if (doc.content.length > 2000) {
+          console.log(chalk.gray(`\n... (${doc.content.length - 2000} more characters)`));
+        }
+      }
+      console.log('');
+    }
+
+    else if (command === 'url') {
+      requireArgs(args.slice(1), 1, 'lux knowledge url <document-id>');
+      const docId = args[1];
+
+      info(`Getting URL for document: ${docId}`);
+      const { data } = await axios.get(
+        `${apiUrl}/api/knowledge/documents/${docId}/presigned-url`,
+        { headers: getAuthHeaders() }
+      );
+
+      console.log(`\n${chalk.bold('Public URL:')}`);
+      console.log(data.presignedUrl);
+      console.log(`\nDocument: ${data.document.name} (${formatFileSize(data.document.file_size)})`);
+      console.log('');
+    }
+
+    else if (command === 'upload') {
+      requireArgs(args.slice(1), 1, 'lux knowledge upload <file-path> [folder-id]');
+      const filePath = args[1];
+      const folderId = args[2] || null;
+
+      // Check file exists
+      if (!fs.existsSync(filePath)) {
+        error(`File not found: ${filePath}`);
+        return;
+      }
+
+      const fileName = path.basename(filePath);
+      const fileBuffer = fs.readFileSync(filePath);
+      const fileSize = fileBuffer.length;
+
+      // Detect MIME type
+      const ext = path.extname(fileName).toLowerCase();
+      const mimeTypes = {
+        '.txt': 'text/plain',
+        '.json': 'application/json',
+        '.md': 'text/markdown',
+        '.csv': 'text/csv',
+        '.html': 'text/html',
+        '.xml': 'text/xml',
+        '.pdf': 'application/pdf',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+      };
+      const fileType = mimeTypes[ext] || 'application/octet-stream';
+
+      info(`Uploading: ${fileName} (${formatFileSize(fileSize)})`);
+
+      // Step 1: Get presigned upload URL
+      const { data: uploadData } = await axios.post(
+        `${apiUrl}/api/knowledge/upload`,
+        { fileName, fileType },
+        { headers: getAuthHeaders() }
+      );
+
+      // Step 2: Upload to R2
+      info('Uploading to storage...');
+      await axios.put(uploadData.uploadUrl, fileBuffer, {
+        headers: {
+          'Content-Type': fileType,
+        },
+        maxBodyLength: Infinity,
+        maxContentLength: Infinity,
+      });
+
+      // Step 3: Complete upload (save to database)
+      info('Saving document metadata...');
+      const { data: completeData } = await axios.put(
+        `${apiUrl}/api/knowledge/upload`,
+        {
+          filePath: uploadData.filePath,
+          fileName,
+          fileType,
+          folderId,
+          fileSize,
+        },
+        { headers: getAuthHeaders() }
+      );
+
+      success('Document uploaded!');
+      console.log(`  ID: ${completeData.document.id}`);
+      console.log(`  Name: ${completeData.document.name}`);
+      if (completeData.document.public_url) {
+        console.log(`  URL: ${completeData.document.public_url}`);
+      }
+      console.log('');
+    }
+
+    else if (command === 'delete') {
+      requireArgs(args.slice(1), 1, 'lux knowledge delete <document-id>');
+      const docId = args[1];
+
+      info(`Deleting document: ${docId}`);
+      await axios.delete(
+        `${apiUrl}/api/knowledge/documents/${docId}`,
+        { headers: getAuthHeaders() }
+      );
+
+      success('Document deleted!');
+    }
+
+    // ============ FOLDER COMMANDS ============
+    else if (command === 'folders') {
+      const subCommand = args[1];
+
+      if (!subCommand || subCommand === 'list') {
+        info('Loading folders...');
+        const { data } = await axios.get(`${apiUrl}/api/knowledge/folders`, {
+          headers: getAuthHeaders(),
+        });
+
+        if (!data.folders || data.folders.length === 0) {
+          console.log('\n(No folders found)\n');
+        } else {
+          console.log(`\nFound ${data.folders.length} folder(s):\n`);
+          formatTable(data.folders.map(f => ({
+            id: f.id,
+            name: f.name,
+            path: f.path,
+            parent: f.parent_id || '(root)',
+          })));
+          console.log('');
+        }
+      }
+
+      else if (subCommand === 'create') {
+        requireArgs(args.slice(2), 1, 'lux knowledge folders create <name> [parent-id]');
+        const name = args[2];
+        const parentId = args[3] || null;
+
+        // Calculate path
+        let folderPath = `/${name}`;
+        if (parentId) {
+          // Fetch parent to get its path
+          const { data: foldersData } = await axios.get(`${apiUrl}/api/knowledge/folders`, {
+            headers: getAuthHeaders(),
+          });
+          const parent = (foldersData.folders || []).find(f => f.id === parentId);
+          if (parent) {
+            folderPath = `${parent.path}/${name}`;
+          }
+        }
+
+        info(`Creating folder: ${name}`);
+        const { data } = await axios.post(
+          `${apiUrl}/api/knowledge/folders`,
+          { name, parent_id: parentId, path: folderPath },
+          { headers: getAuthHeaders() }
+        );
+
+        success('Folder created!');
+        console.log(`  ID: ${data.folder.id}`);
+        console.log(`  Name: ${data.folder.name}`);
+        console.log(`  Path: ${data.folder.path}`);
+        console.log('');
+      }
+
+      else if (subCommand === 'delete') {
+        requireArgs(args.slice(2), 1, 'lux knowledge folders delete <folder-id>');
+        const folderId = args[2];
+
+        info(`Deleting folder: ${folderId}`);
+        await axios.delete(
+          `${apiUrl}/api/knowledge/folders?id=${folderId}`,
+          { headers: getAuthHeaders() }
+        );
+
+        success('Folder deleted!');
+      }
+
+      else {
+        error(`Unknown folder subcommand: ${subCommand}`);
+      }
+    }
+
+    else {
+      error(`Unknown command: ${command}\n\nRun 'lux knowledge' to see available commands`);
+    }
+  } catch (err) {
+    const errorMessage =
+      err.response?.data?.error || err.message || 'Unknown error';
+    error(`${errorMessage}`);
+  }
+}
+
+function formatFileSize(bytes) {
+  if (!bytes || bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+module.exports = { handleKnowledge };

package/commands/link.js

@@ -0,0 +1,127 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const ora = require('ora');
+const {
+  saveInterfaceConfig,
+  loadInterfaceConfig,
+  getApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+} = require('../lib/config');
+
+async function link(interfaceId) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  if (!interfaceId) {
+    console.log(chalk.red('❌ Interface ID required.'));
+    console.log(chalk.dim('Usage:'), chalk.white('lux link <interface-id>'));
+    process.exit(1);
+  }
+
+  // Check if already linked
+  const existing = loadInterfaceConfig();
+  if (existing && existing.id) {
+    console.log(
+      chalk.yellow('⚠️  Already linked to:'),
+      existing.name,
+      chalk.dim(`(${existing.id})`)
+    );
+
+    const inquirer = require('inquirer');
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Do you want to relink to a different interface?',
+        default: false,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.dim('Cancelled.'));
+      return;
+    }
+  }
+
+  const apiUrl = getApiUrl();
+  const spinner = ora('Fetching interface...').start();
+
+  try {
+    // Fetch interface details
+    const { data } = await axios.get(
+      `${apiUrl}/api/interfaces/${interfaceId}`,
+      {
+        headers: getAuthHeaders(),
+      }
+    );
+
+    const iface = data.interface;
+
+    if (!iface) {
+      spinner.fail('Interface not found');
+      process.exit(1);
+    }
+
+    spinner.succeed(chalk.green('✓ Found interface'));
+
+    // Save config
+    const config = {
+      id: iface.id,
+      name: iface.name,
+      description: iface.description,
+      githubRepoUrl: iface.github_repo_url,
+      deploymentUrl: iface.vercel_deployment_url,
+      linkedAt: new Date().toISOString(),
+    };
+
+    saveInterfaceConfig(config);
+
+    console.log(chalk.green('\n✓ Linked successfully!\n'));
+    console.log(chalk.white(iface.name));
+    console.log(chalk.dim(iface.description || 'No description'));
+
+    if (iface.vercel_deployment_url) {
+      console.log(chalk.cyan(`\n${iface.vercel_deployment_url}`));
+    }
+
+    console.log(chalk.dim('\nYou can now run:'));
+    console.log(chalk.white('  lux up'), chalk.dim('- Upload changes'));
+    console.log(
+      chalk.white('  lux deploy'),
+      chalk.dim('- Deploy to production')
+    );
+    console.log(chalk.white('  lux logs'), chalk.dim('- View logs\n'));
+  } catch (error) {
+    spinner.fail('Failed to link');
+    console.error(
+      chalk.red('\n❌ Error:'),
+      error.response?.data?.error || error.message
+    );
+
+    if (error.response?.status === 401) {
+      console.log(
+        chalk.yellow('\nYour session may have expired. Try running:'),
+        chalk.white('lux login')
+      );
+    } else if (error.response?.status === 404) {
+      console.log(
+        chalk.yellow('\nInterface not found. Check the ID and try again.')
+      );
+      console.log(chalk.dim('List interfaces with:'), chalk.white('lux list'));
+    }
+
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  link,
+};

package/commands/list.js

@@ -0,0 +1,97 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const { getApiUrl, getAuthHeaders, isAuthenticated } = require('../lib/config');
+
+async function list(options) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const apiUrl = getApiUrl();
+
+  try {
+    const { data } = await axios.get(`${apiUrl}/api/interfaces`, {
+      headers: getAuthHeaders(),
+    });
+
+    const interfaces = data.interfaces || [];
+
+    if (interfaces.length === 0) {
+      console.log(chalk.yellow('\nNo interfaces found.'));
+      console.log(
+        chalk.dim('Create one with:'),
+        chalk.white('lux init'),
+        chalk.dim('and'),
+        chalk.white('lux up\n')
+      );
+      return;
+    }
+
+    console.log(chalk.cyan(`\n📦 Interfaces (${interfaces.length})\n`));
+
+    for (const iface of interfaces) {
+      const status = getStatusDisplay(iface.status);
+
+      console.log(
+        `📱 ${chalk.white(iface.name)} ${chalk.dim(`(${iface.id})`)}`
+      );
+      console.log(
+        `   ${status} ${chalk.dim(iface.description || 'No description')}`
+      );
+
+      if (iface.vercel_deployment_url) {
+        console.log(`   ${chalk.cyan(iface.vercel_deployment_url)}`);
+      }
+
+      if (iface.github_repo_url) {
+        console.log(`   ${chalk.dim(iface.github_repo_url)}`);
+      }
+
+      console.log('');
+    }
+
+    console.log(
+      chalk.dim('Link to an interface: '),
+      chalk.white('lux link <interface-id>\n')
+    );
+  } catch (error) {
+    console.error(
+      chalk.red('\n❌ Error:'),
+      error.response?.data?.error || error.message
+    );
+
+    if (error.response?.status === 401) {
+      console.log(
+        chalk.yellow('\nYour session may have expired. Try running:'),
+        chalk.white('lux login')
+      );
+    }
+
+    process.exit(1);
+  }
+}
+
+function getStatusDisplay(status) {
+  switch (status) {
+    case 'draft':
+      return chalk.gray('○ draft');
+    case 'building':
+      return chalk.yellow('◐ building');
+    case 'published':
+      return chalk.green('● published');
+    case 'failed':
+      return chalk.red('✕ failed');
+    default:
+      return chalk.gray(`○ ${status}`);
+  }
+}
+
+module.exports = {
+  list,
+};