@descix/cli 1.0.0

package/lib/commands/folder.js

@@ -0,0 +1,291 @@
+/**
+ * Folder Commands - Drive Folder Management
+ * 
+ * Commands for managing Drive folder IDs for entities:
+ *   descix folder set --user/--community/--app/--kb <folder-id>
+ *   descix folder get --user/--community/--app/--kb
+ *   descix folder allocate --app/--kb
+ *   descix folder validate <folder-id>
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { DeSciXApiClient } from '../api-client.js';
+import { requireAuth } from '../auth-guard.js';
+import { GlobalConfig } from '../global-config.js';
+
+/**
+ * Extract folder ID from Drive URL or return as-is
+ */
+function extractFolderId(input) {
+  if (!input) return null;
+  
+  const trimmed = input.trim();
+  
+  // Handle full URLs
+  if (trimmed.includes('drive.google.com')) {
+    const foldersMatch = trimmed.match(/\/folders\/([a-zA-Z0-9_-]+)/);
+    if (foldersMatch && foldersMatch[1]) return foldersMatch[1];
+    
+    const dMatch = trimmed.match(/\/d\/([a-zA-Z0-9_-]+)/);
+    if (dMatch && dMatch[1]) return dMatch[1];
+    
+    const idMatch = trimmed.match(/[?&]id=([a-zA-Z0-9_-]+)/);
+    if (idMatch && idMatch[1]) return idMatch[1];
+  }
+  
+  return trimmed;
+}
+
+/**
+ * Set folder ID for an entity
+ */
+export async function setFolder(options) {
+  const apiClient = new DeSciXApiClient();
+  await requireAuth(apiClient);
+  
+  const spinner = ora('Setting folder...').start();
+  
+  try {
+    let entityType, entityIds, folderId;
+    
+    if (options.user) {
+      entityType = 'user';
+      folderId = extractFolderId(options.user);
+    } else if (options.community) {
+      entityType = 'community';
+      entityIds = { community_id: options.community };
+      folderId = extractFolderId(options.folderId);
+    } else if (options.app) {
+      entityType = 'app';
+      // Parse "community app" format
+      const parts = options.app.split(/\s+/);
+      if (parts.length < 2) {
+        throw new Error('App requires both community and app ID: --app "community app"');
+      }
+      entityIds = { community_id: parts[0], app_id: parts[1] };
+      folderId = extractFolderId(options.folderId);
+    } else if (options.kb) {
+      entityType = 'kb';
+      // Parse "community app kb" format
+      const parts = options.kb.split(/\s+/);
+      if (parts.length < 3) {
+        throw new Error('KB requires community, app, and kb ID: --kb "community app kb"');
+      }
+      entityIds = { community_id: parts[0], app_id: parts[1], kb_id: parts[2] };
+      folderId = extractFolderId(options.folderId);
+    } else {
+      throw new Error('Specify entity type: --user, --community, --app, or --kb');
+    }
+    
+    if (!folderId) {
+      throw new Error('Folder ID is required');
+    }
+    
+    const response = await apiClient.invoke('set_folder_id', {
+      entity_type: entityType,
+      entity_ids: entityIds,
+      folder_id: folderId
+    });
+    
+    const result = response.message || response;
+    
+    spinner.succeed('Folder set successfully');
+    
+    console.log(chalk.green(`\n✓ ${result.message}`));
+    console.log(chalk.gray(`  Entity: ${entityType}`));
+    console.log(chalk.gray(`  Folder: ${folderId}`));
+    console.log(chalk.cyan(`  URL: https://drive.google.com/drive/folders/${folderId}\n`));
+    
+    // Update global config if setting user folder
+    if (entityType === 'user') {
+      const globalConfig = await GlobalConfig.load();
+      globalConfig.user_base_folder_id = folderId;
+      globalConfig.registered_at = new Date().toISOString();
+      await globalConfig.save();
+    }
+    
+    return result;
+    
+  } catch (error) {
+    spinner.fail('Failed to set folder');
+    console.error(chalk.red(`\n❌ ${error.message}\n`));
+    throw error;
+  }
+}
+
+/**
+ * Get folder info for an entity
+ */
+export async function getFolder(options) {
+  const apiClient = new DeSciXApiClient();
+  await requireAuth(apiClient);
+  
+  const spinner = ora('Getting folder info...').start();
+  
+  try {
+    let entityType, entityIds;
+    
+    if (options.user) {
+      entityType = 'user';
+    } else if (options.community) {
+      entityType = 'community';
+      entityIds = { community_id: options.community };
+    } else if (options.app) {
+      entityType = 'app';
+      const parts = options.app.split(/\s+/);
+      if (parts.length < 2) {
+        throw new Error('App requires both community and app ID: --app "community app"');
+      }
+      entityIds = { community_id: parts[0], app_id: parts[1] };
+    } else if (options.kb) {
+      entityType = 'kb';
+      const parts = options.kb.split(/\s+/);
+      if (parts.length < 3) {
+        throw new Error('KB requires community, app, and kb ID: --kb "community app kb"');
+      }
+      entityIds = { community_id: parts[0], app_id: parts[1], kb_id: parts[2] };
+    } else {
+      throw new Error('Specify entity type: --user, --community, --app, or --kb');
+    }
+    
+    const response = await apiClient.invoke('get_folder_info', {
+      entity_type: entityType,
+      entity_ids: entityIds
+    });
+    
+    const result = response.message || response;
+    
+    spinner.succeed('Folder info retrieved');
+    
+    console.log(chalk.cyan(`\n📁 Folder Info: ${entityType}\n`));
+    
+    if (result.has_folder) {
+      console.log(chalk.green(`  ✓ Folder registered`));
+      console.log(chalk.white(`    ID: ${result.folder_id}`));
+      if (result.folder_name) {
+        console.log(chalk.white(`    Name: ${result.folder_name}`));
+      }
+      if (result.kb_folder_id) {
+        console.log(chalk.white(`    KB Folder: ${result.kb_folder_id}`));
+      }
+      console.log(chalk.cyan(`    URL: https://drive.google.com/drive/folders/${result.folder_id}`));
+    } else {
+      console.log(chalk.yellow(`  ⚠ No folder registered`));
+      console.log(chalk.gray(`    Use 'descix folder set' to register a folder`));
+    }
+    
+    console.log('');
+    return result;
+    
+  } catch (error) {
+    spinner.fail('Failed to get folder info');
+    console.error(chalk.red(`\n❌ ${error.message}\n`));
+    throw error;
+  }
+}
+
+/**
+ * Allocate a new folder for an entity
+ */
+export async function allocateFolder(options) {
+  const apiClient = new DeSciXApiClient();
+  await requireAuth(apiClient);
+  
+  const spinner = ora('Allocating folder...').start();
+  
+  try {
+    let entityType, entityIds, folderName;
+    
+    if (options.app) {
+      entityType = 'app';
+      const parts = options.app.split(/\s+/);
+      if (parts.length < 2) {
+        throw new Error('App requires both community and app ID: --app "community app"');
+      }
+      entityIds = { community_id: parts[0], app_id: parts[1] };
+      folderName = options.name || `${parts[0]}_${parts[1]}`;
+    } else if (options.kb) {
+      entityType = 'kb';
+      const parts = options.kb.split(/\s+/);
+      if (parts.length < 3) {
+        throw new Error('KB requires community, app, and kb ID: --kb "community app kb"');
+      }
+      entityIds = { community_id: parts[0], app_id: parts[1], kb_id: parts[2] };
+      folderName = options.name || parts[2];
+    } else {
+      throw new Error('Specify entity type: --app or --kb');
+    }
+    
+    const response = await apiClient.invoke('allocate_folder', {
+      entity_type: entityType,
+      entity_ids: entityIds,
+      folder_name: folderName
+    });
+    
+    const result = response.message || response;
+    
+    spinner.succeed('Folder allocated successfully');
+    
+    console.log(chalk.green(`\n✓ New folder created`));
+    console.log(chalk.white(`  Name: ${result.folder_name}`));
+    console.log(chalk.white(`  ID: ${result.folder_id}`));
+    console.log(chalk.cyan(`  URL: ${result.drive_url}\n`));
+    
+    return result;
+    
+  } catch (error) {
+    spinner.fail('Failed to allocate folder');
+    console.error(chalk.red(`\n❌ ${error.message}\n`));
+    throw error;
+  }
+}
+
+/**
+ * Validate folder access
+ */
+export async function validateFolder(folderId, options = {}) {
+  const apiClient = new DeSciXApiClient();
+  await requireAuth(apiClient);
+  
+  const spinner = ora('Validating folder...').start();
+  
+  try {
+    const parsedFolderId = extractFolderId(folderId);
+    
+    if (!parsedFolderId) {
+      throw new Error('Folder ID is required');
+    }
+    
+    const response = await apiClient.invoke('validate_folder_access', {
+      folder_id: parsedFolderId
+    });
+    
+    const result = response.message || response;
+    
+    if (result.accessible) {
+      spinner.succeed('Folder is accessible');
+      console.log(chalk.green(`\n✓ ${result.message}`));
+      console.log(chalk.white(`  Name: ${result.folder_name}`));
+      console.log(chalk.white(`  ID: ${parsedFolderId}`));
+      console.log(chalk.cyan(`  URL: https://drive.google.com/drive/folders/${parsedFolderId}\n`));
+    } else {
+      spinner.fail('Folder not accessible');
+      console.log(chalk.red(`\n❌ ${result.message}\n`));
+    }
+    
+    return result;
+    
+  } catch (error) {
+    spinner.fail('Validation failed');
+    console.error(chalk.red(`\n❌ ${error.message}\n`));
+    throw error;
+  }
+}
+
+export default {
+  setFolder,
+  getFolder,
+  allocateFolder,
+  validateFolder
+};

package/lib/commands/init.js

@@ -0,0 +1,257 @@
+/**
+ * DeSciX CLI Init Command
+ *
+ * Creates .descix/workspace.json (template-based creation is via PWA/Admin CLI).
+ */
+
+import chalk from 'chalk';
+import readline from 'readline';
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// clone.js is imported dynamically inside the invite flow to avoid circular deps
+import { WorkspaceConfig } from '../workspace-config.js';
+import { generateAgentFiles } from '../agent-files.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Create readline interface for interactive prompts
+ */
+function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Ask for text input with optional default
+ */
+function askInput(rl, question, defaultValue = '') {
+  return new Promise((resolve) => {
+    const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+    rl.question(prompt, (answer) => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+/**
+ * Ask a yes/no question
+ */
+function askYesNo(rl, question, defaultYes = true) {
+  return new Promise((resolve) => {
+    const suffix = defaultYes ? '(Y/n)' : '(y/N)';
+    rl.question(`${question} ${suffix}: `, (answer) => {
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === '') {
+        resolve(defaultYes);
+      } else {
+        resolve(trimmed === 'y' || trimmed === 'yes');
+      }
+    });
+  });
+}
+
+/**
+ * Run the init command
+ * @param {Object} apiClient - API client (optional, for listing communities)
+ * @param {Object} options - Command options
+ */
+export async function runInit(apiClient, options = {}) {
+  const rl = createPrompt();
+  const projectPath = options.path ? path.resolve(options.path) : process.cwd();
+
+  // If --from-invite provided, resolve the invite first to pre-fill context
+  if (options.fromInvite) {
+    if (!apiClient) {
+      console.error(chalk.red('\n❌ Authentication required for --from-invite. Run "descix login" first.\n'));
+      rl.close();
+      return {};
+    }
+    try {
+      console.log(chalk.cyan('Resolving invite...\n'));
+      const inviteData = await apiClient.invoke('resolve_invite', { invite_token: options.fromInvite });
+
+      // Write app.json seed file
+      const descixDir = join(projectPath, '.descix');
+      await fs.mkdir(descixDir, { recursive: true });
+      const appJson = {
+        version: '1.0',
+        invite_token: options.fromInvite,
+        invite_type: inviteData.invite_type,
+        app_id: inviteData.app_id,
+        community_id: inviteData.community_id,
+        app_name: inviteData.app_name,
+        agent_hint: inviteData.agent_hint,
+        kb_ready: inviteData.kb_ready,
+        has_repo: inviteData.has_repo
+      };
+      await fs.writeFile(join(descixDir, 'app.json'), JSON.stringify(appJson, null, 2));
+
+      console.log(chalk.green(`Invite resolved: ${inviteData.app_name} (${inviteData.community_id}/${inviteData.app_id})`));
+      if (inviteData.agent_hint) {
+        console.log(chalk.gray(`Agent hint: ${inviteData.agent_hint}`));
+      }
+
+      // Auto-fill community and app for the rest of init
+      options.community = options.community || inviteData.community_id;
+      options.app = options.app || inviteData.app_id;
+
+      // Offer to clone if repo exists
+      if (inviteData.has_repo) {
+        console.log(chalk.cyan('\nThis app has a linked repository.'));
+        const { runClone } = await import('./clone.js');
+        await runClone(apiClient, { app_id: inviteData.app_id });
+      }
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Failed to resolve invite: ${error.message}\n`));
+      rl.close();
+      return {};
+    }
+  }
+  
+  console.log(chalk.cyan('\n╔════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║     DeSciX Workspace Initialization        ║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════╝\n'));
+
+  try {
+    const descixDir = join(projectPath, '.descix');
+    const configPath = join(descixDir, 'workspace.json');
+    let hasExisting = false;
+    try {
+      await fs.access(configPath);
+      hasExisting = true;
+    } catch {
+      // No existing config
+    }
+
+    if (hasExisting && !options.force) {
+      const overwrite = await askYesNo(rl, chalk.yellow('Workspace already initialized. Overwrite?'), false);
+      if (!overwrite) {
+        console.log(chalk.gray('\nInitialization cancelled.\n'));
+        rl.close();
+        return {};
+      }
+    }
+
+    let communityId = options.community;
+    if (!communityId) {
+      if (apiClient) {
+        try {
+          const response = await apiClient.invoke('find_communities', {});
+          const communities = response.message?.communities || [];
+          if (communities.length > 0) {
+            console.log(chalk.cyan('Available Communities:'));
+            communities.slice(0, 10).forEach((c, i) => {
+              console.log(chalk.gray(`  ${i + 1}. ${c.community_id} (${c.community_name})`));
+            });
+            if (communities.length > 10) console.log(chalk.gray(`  ... and ${communities.length - 10} more`));
+            console.log();
+          }
+        } catch {
+          // ignore
+        }
+      }
+      communityId = await askInput(rl, chalk.white('Community ID'));
+      if (!communityId) {
+        console.log(chalk.red('\n❌ Community ID is required.\n'));
+        rl.close();
+        return {};
+      }
+    }
+
+    const defaultAppName = path.basename(projectPath).toLowerCase().replace(/[^a-z0-9]/g, '_');
+    let appName = options.app;
+    if (!appName) {
+      appName = await askInput(rl, chalk.white('App name'), defaultAppName);
+      if (!appName) {
+        console.log(chalk.red('\n❌ App name is required.\n'));
+        rl.close();
+        return {};
+      }
+    }
+
+    const appId = appName.toLowerCase().replace(/[^a-z0-9_-]/g, '_');
+    console.log(chalk.cyan('\n─── Summary ───\n'));
+    console.log(chalk.white(`  Project:   ${projectPath}`));
+    console.log(chalk.white(`  Community: ${communityId}`));
+    console.log(chalk.white(`  App:       ${appName} (${appId})`));
+
+    const proceed = await askYesNo(rl, chalk.white('\nProceed?'), true);
+    if (!proceed) {
+      console.log(chalk.gray('\nCancelled.\n'));
+      rl.close();
+      return {};
+    }
+
+    console.log(chalk.gray('\nWriting .descix/workspace.json...\n'));
+    const config = new WorkspaceConfig({ version: '2.0', type: 'workspace', communities: {} }, projectPath);
+    config.registerApp(communityId, appId, { localPath: '.', kbId: 'General' });
+    await config.save(projectPath);
+
+    console.log(chalk.green('Created:'));
+    console.log(chalk.green('  ✓ .descix/workspace.json'));
+
+    // Generate agent instruction files with correct context
+    try {
+      const agentFilesWritten = await generateAgentFiles(projectPath);
+      for (const f of agentFilesWritten) {
+        console.log(chalk.green(`  ✓ ${f}`));
+      }
+    } catch {
+      // Agent file generation is best-effort
+    }
+
+    console.log(chalk.cyan('\n─── Next Steps ───\n'));
+    console.log(chalk.white(`  1. descix app init -a ${appId} -c ${communityId}    # register app on platform`));
+    console.log(chalk.white(`  2. descix update kb -c ${communityId} -a ${appId}   # sync KB to Pinecone`));
+    console.log(chalk.white(`  3. descix chat -c ${communityId} -a ${appId} -q "test"  # verify RAG\n`));
+    console.log(chalk.green('✅ Workspace initialized.\n'));
+    rl.close();
+    return { created: ['.descix/workspace.json'], skipped: [], warnings: [] };
+
+  } catch (error) {
+    rl.close();
+    throw error;
+  }
+}
+
+/**
+ * Non-interactive init: writes .descix/workspace.json only.
+ * @param {Object} options - { path?, communityId, appName? }
+ * @returns {Promise<Object>} { created, skipped, warnings }
+ */
+export async function initWorkspace(options) {
+  const projectPath = options.path ? path.resolve(options.path) : process.cwd();
+  const communityId = options.communityId;
+  const appName = options.appName || path.basename(projectPath).toLowerCase().replace(/[^a-z0-9]/g, '_');
+  const appId = appName.toLowerCase().replace(/[^a-z0-9_-]/g, '_');
+  if (!communityId) {
+    throw new Error('communityId is required');
+  }
+  const config = new WorkspaceConfig({ version: '2.0', type: 'workspace', communities: {} }, projectPath);
+  config.registerApp(communityId, appId, { localPath: '.', kbId: 'General' });
+  await config.save(projectPath);
+
+  // Generate agent instruction files with workspace context
+  const created = ['.descix/workspace.json'];
+  try {
+    const agentFilesWritten = await generateAgentFiles(projectPath);
+    created.push(...agentFilesWritten);
+  } catch {
+    // Best-effort
+  }
+
+  return {
+    created,
+    skipped: [],
+    warnings: [],
+    nextSteps: [`descix app init -a ${appId} -c ${communityId}`, `descix update kb -c ${communityId} -a ${appId}`]
+  };
+}
+
+export default { runInit, initWorkspace };