@nestbox-ai/cli 1.0.38 → 1.0.39

package/src/utils/agent.ts

@@ -1,154 +1,170 @@
 import path from "path";
-import fs from 'fs';
+import fs from "fs";
 import chalk from "chalk";
 import ora from "ora";
 import { promisify } from "util";
 import { exec } from "child_process";
 import AdmZip from "adm-zip";
-import * as os from 'os';
+import * as os from "os";
 import axios from "axios";
 
-
 const execAsync = promisify(exec);
 
 export async function findProjectRoot(startDir = process.cwd()) {
-  let currentDir = startDir;
-  
-  while (currentDir !== path.parse(currentDir).root) {
-    const nestboxConfigPath = path.join(currentDir, 'nestbox.config.json');
-    const packageJsonPath = path.join(currentDir, 'package.json');
-    
-    if (fs.existsSync(nestboxConfigPath) || fs.existsSync(packageJsonPath)) {
-      return currentDir;
-    }
-    
-    currentDir = path.dirname(currentDir);
-  }
-  
-  return startDir; // Fallback to current directory if no root markers found
+	let currentDir = startDir;
+
+	while (currentDir !== path.parse(currentDir).root) {
+		const nestboxConfigPath = path.join(currentDir, "nestbox.config.json");
+		const packageJsonPath = path.join(currentDir, "package.json");
+
+		if (
+			fs.existsSync(nestboxConfigPath) ||
+			fs.existsSync(packageJsonPath)
+		) {
+			return currentDir;
+		}
+
+		currentDir = path.dirname(currentDir);
+	}
+
+	return startDir; // Fallback to current directory if no root markers found
 }
 
 // Function to load and parse nestbox.config.json if it exists
 export function loadNestboxConfig(projectRoot: any) {
-  const configPath = path.join(projectRoot, 'nestbox.config.json');
-  
-  if (fs.existsSync(configPath)) {
-    try {
-      const configContent = fs.readFileSync(configPath, 'utf8');
-      return JSON.parse(configContent);
-    } catch (error: any) {
-      console.warn(chalk.yellow(`Warning: Error parsing nestbox.config.json: ${error.message}`));
-    }
-  }
-  
-  return null;
+	const configPath = path.join(projectRoot, "nestbox.config.json");
+
+	if (fs.existsSync(configPath)) {
+		try {
+			const configContent = fs.readFileSync(configPath, "utf8");
+			return JSON.parse(configContent);
+		} catch (error: any) {
+			console.warn(
+				chalk.yellow(
+					`Warning: Error parsing nestbox.config.json: ${error.message}`
+				)
+			);
+		}
+	}
+
+	return null;
 }
 
 // Function to detect if a directory contains TypeScript files
 export function isTypeScriptProject(directoryPath: any) {
-  // Check for tsconfig.json
-  if (fs.existsSync(path.join(directoryPath, 'tsconfig.json'))) {
-    return true;
-  }
-  
-  // Check for .ts files
-  try {
-    const files = fs.readdirSync(directoryPath);
-    return files.some(file => file.endsWith('.ts') || file.endsWith('.tsx'));
-  } catch (error) {
-    return false;
-  }
+	// Check for tsconfig.json
+	if (fs.existsSync(path.join(directoryPath, "tsconfig.json"))) {
+		return true;
+	}
+
+	// Check for .ts files
+	try {
+		const files = fs.readdirSync(directoryPath);
+		return files.some(
+			file => file.endsWith(".ts") || file.endsWith(".tsx")
+		);
+	} catch (error) {
+		return false;
+	}
 }
 
 export async function runPredeployScripts(scripts: any, projectRoot: any) {
-  if (!scripts || !Array.isArray(scripts) || scripts.length === 0) {
-    return;
-  }
-  
-  const spinner = ora('Running predeploy scripts...').start();
-
-  try {
-    for (const script of scripts) {
-      spinner.text = `Running: ${script}`;
-      
-      // Make sure we're running in the correct directory
-      await execAsync(script, { 
-        cwd: projectRoot,
-      });
-    }
-    spinner.succeed('Predeploy scripts completed successfully');
-  } catch (error: any) {
-    spinner.fail(`Predeploy script failed: ${error.message}`);
-    throw new Error(`Predeploy failed: ${error.message}`);
-  }
+	if (!scripts || !Array.isArray(scripts) || scripts.length === 0) {
+		return;
+	}
+
+	const spinner = ora("Running predeploy scripts...").start();
+
+	try {
+		for (const script of scripts) {
+			spinner.text = `Running: ${script}`;
+
+			// Make sure we're running in the correct directory
+			await execAsync(script, {
+				cwd: projectRoot,
+			});
+		}
+		spinner.succeed("Predeploy scripts completed successfully");
+	} catch (error: any) {
+		spinner.fail(`Predeploy script failed: ${error.message}`);
+		throw new Error(`Predeploy failed: ${error.message}`);
+	}
 }
 
-export function createZipFromDirectory(dirPath: any, excludePatterns = ['node_modules']) {
-  const dirName = path.basename(dirPath);
-  const timestamp = Date.now();
-  
-  // Create zip in temp directory
-  const tempZipFilePath = path.join(os.tmpdir(), `${dirName}_${timestamp}.zip`);
-    
-  const zip = new AdmZip();
-    
-  // Function to recursively add files to zip
-  function addFilesToZip(currentPath: any, relativePath = '') {
-    const items = fs.readdirSync(currentPath);
-    
-    for (const item of items) {
-      const itemPath = path.join(currentPath, item);
-      const itemRelativePath = path.join(relativePath, item);
-      
-      // Check if item should be excluded
-      if (excludePatterns.some((pattern: any) => 
-        typeof pattern === 'string' ? itemRelativePath === pattern || item === pattern : 
-        pattern.test(itemRelativePath)
-      )) {
-        continue;
-      }
-      
-      const stats = fs.statSync(itemPath);
-      
-      if (stats.isDirectory()) {
-        addFilesToZip(itemPath, itemRelativePath);
-      } else {
-        zip.addLocalFile(itemPath, path.dirname(itemRelativePath));
-      }
-    }
-  }
-  
-  addFilesToZip(dirPath);
-  
-  // Write zip to temp directory (for upload)
-  zip.writeZip(tempZipFilePath);
-  
-  // Return the temp path for upload
-  return tempZipFilePath;
+export function createZipFromDirectory(
+	dirPath: any,
+	excludePatterns = ["node_modules"]
+) {
+	const dirName = path.basename(dirPath);
+	const timestamp = Date.now();
+
+	// Create zip in temp directory
+	const tempZipFilePath = path.join(
+		os.tmpdir(),
+		`${dirName}_${timestamp}.zip`
+	);
+
+	const zip = new AdmZip();
+
+	// Function to recursively add files to zip
+	function addFilesToZip(currentPath: any, relativePath = "") {
+		const items = fs.readdirSync(currentPath);
+
+		for (const item of items) {
+			const itemPath = path.join(currentPath, item);
+			const itemRelativePath = path.join(relativePath, item);
+
+			// Check if item should be excluded
+			if (
+				excludePatterns.some((pattern: any) =>
+					typeof pattern === "string"
+						? itemRelativePath === pattern || item === pattern
+						: pattern.test(itemRelativePath)
+				)
+			) {
+				continue;
+			}
+
+			const stats = fs.statSync(itemPath);
+
+			if (stats.isDirectory()) {
+				addFilesToZip(itemPath, itemRelativePath);
+			} else {
+				zip.addLocalFile(itemPath, path.dirname(itemRelativePath));
+			}
+		}
+	}
+
+	addFilesToZip(dirPath);
+
+	// Write zip to temp directory (for upload)
+	zip.writeZip(tempZipFilePath);
+
+	// Return the temp path for upload
+	return tempZipFilePath;
 }
 
 export interface TemplateInfo {
-  name: string;
-  description: string;
-  fileId: string;
-  lang: string;
-  type: string;
+	name: string;
+	description: string;
+	fileId: string;
+	lang: string;
+	type: string;
 }
 
-export function createNestboxConfig(projectPath: string, isTypeScript: boolean): void {
-  if (!isTypeScript) return;
-
-  const configPath = path.join(projectPath, 'nestbox.config.json');
-  const config = {
-    agents: {
-      predeploy: [
-        'rm -rf dist',
-        'npm run lint',
-        'npm run build'
-      ]
-    }
-  };
-
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  console.log(chalk.green(`Created nestbox.config.json at ${configPath}`));
-}
+export function createNestboxConfig(
+	projectPath: string,
+	isTypeScript: boolean
+): void {
+	if (!isTypeScript) return;
+
+	const configPath = path.join(projectPath, "nestbox.config.json");
+	const config = {
+		agents: {
+			predeploy: ["rm -rf dist", "npm run lint", "npm run build"],
+		},
+	};
+
+	fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+	console.log(chalk.green(`Created nestbox.config.json at ${configPath}`));
+}

package/test/agent.test.ts

@@ -1,125 +1,154 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerAgentCommands } from '../src/commands/agent';
-
-describe('Agent Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerAgentCommands', () => {
-    it('should register agent command group', () => {
-      registerAgentCommands(program);
-
-      const commands = program.commands;
-      const agentCommand = commands.find(cmd => cmd.name() === 'agent');
-
-      expect(agentCommand).toBeDefined();
-      expect(agentCommand?.description()).toBe('Manage Nestbox agents');
-    });
-
-    it('should register agent list subcommand', () => {
-      registerAgentCommands(program);
-
-      const agentCommand = program.commands.find(cmd => cmd.name() === 'agent');
-      const subCommands = agentCommand?.commands || [];
-      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
-
-      expect(listCommand).toBeDefined();
-      expect(listCommand?.description()).toBe('List all AI agents associated with the authenticated user');
-      
-      // Check options
-      const options = listCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      expect(projectOption).toBeDefined();
-      expect(projectOption?.description).toBe('Project name (defaults to the current project)');
-    });
-
-    it('should register agent remove subcommand', () => {
-      registerAgentCommands(program);
-
-      const agentCommand = program.commands.find(cmd => cmd.name() === 'agent');
-      const subCommands = agentCommand?.commands || [];
-      const removeCommand = subCommands.find(cmd => cmd.name() === 'remove');
-
-      expect(removeCommand).toBeDefined();
-      expect(removeCommand?.description()).toBe('Remove an AI agent');
-      
-      // Check options
-      const options = removeCommand?.options || [];
-      const agentOption = options.find(opt => opt.long === '--agent');
-      const projectOption = options.find(opt => opt.long === '--project');
-      
-      expect(agentOption).toBeDefined();
-      expect(projectOption).toBeDefined();
-    });
-
-    it('should register agent deploy subcommand', () => {
-      registerAgentCommands(program);
-
-      const agentCommand = program.commands.find(cmd => cmd.name() === 'agent');
-      const subCommands = agentCommand?.commands || [];
-      const deployCommand = subCommands.find(cmd => cmd.name() === 'deploy');
-
-      expect(deployCommand).toBeDefined();
-      expect(deployCommand?.description()).toBe('Deploy an AI agent to the Nestbox platform');
-      
-      // Check options
-      const options = deployCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      const agentOption = options.find(opt => opt.long === '--agent');
-      const instanceOption = options.find(opt => opt.long === '--instance');
-      
-      expect(projectOption).toBeDefined();
-      expect(agentOption).toBeDefined();
-      expect(instanceOption).toBeDefined();
-    });
-
-    it('should register agent create subcommand', () => {
-      registerAgentCommands(program);
-
-      const agentCommand = program.commands.find(cmd => cmd.name() === 'agent');
-      const subCommands = agentCommand?.commands || [];
-      const createCommand = subCommands.find(cmd => cmd.name() === 'create');
-
-      expect(createCommand).toBeDefined();
-      expect(createCommand?.description()).toBe('Create multiple agents from a YAML configuration file');
-      
-      // Check that it has optional arguments (in command name: "create [firstArg] [secondArg]")
-      expect(createCommand?.name()).toBe('create');
-      
-      // Check options
-      const options = createCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      
-      expect(projectOption).toBeDefined();
-    });
-
-    it('should have all expected agent subcommands', () => {
-      registerAgentCommands(program);
-
-      const agentCommand = program.commands.find(cmd => cmd.name() === 'agent');
-      const subCommandNames = agentCommand?.commands.map(cmd => cmd.name()) || [];
-      
-      expect(subCommandNames).toContain('list');
-      expect(subCommandNames).toContain('remove');
-      expect(subCommandNames).toContain('deploy');
-      expect(subCommandNames).toContain('create');
-      expect(subCommandNames).toHaveLength(4);
-    });
-
-    it('should have proper action functions for all subcommands', () => {
-      registerAgentCommands(program);
-
-      const agentCommand = program.commands.find(cmd => cmd.name() === 'agent');
-      const subCommands = agentCommand?.commands || [];
-      
-      subCommands.forEach(cmd => {
-        expect(typeof cmd.action).toBe('function');
-      });
-    });
-  });
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Command } from "commander";
+import { registerAgentCommands } from "../src/commands/agent";
+
+describe("Agent Commands", () => {
+	let program: Command;
+
+	beforeEach(() => {
+		program = new Command();
+		vi.clearAllMocks();
+	});
+
+	describe("registerAgentCommands", () => {
+		it("should register agent command group", () => {
+			registerAgentCommands(program);
+
+			const commands = program.commands;
+			const agentCommand = commands.find(cmd => cmd.name() === "agent");
+
+			expect(agentCommand).toBeDefined();
+			expect(agentCommand?.description()).toBe("Manage Nestbox agents");
+		});
+
+		it("should register agent list subcommand", () => {
+			registerAgentCommands(program);
+
+			const agentCommand = program.commands.find(
+				cmd => cmd.name() === "agent"
+			);
+			const subCommands = agentCommand?.commands || [];
+			const listCommand = subCommands.find(cmd => cmd.name() === "list");
+
+			expect(listCommand).toBeDefined();
+			expect(listCommand?.description()).toBe(
+				"List all AI agents associated with the authenticated user"
+			);
+
+			// Check options
+			const options = listCommand?.options || [];
+			const projectOption = options.find(opt => opt.long === "--project");
+			expect(projectOption).toBeDefined();
+			expect(projectOption?.description).toBe(
+				"Project name (defaults to the current project)"
+			);
+		});
+
+		it("should register agent remove subcommand", () => {
+			registerAgentCommands(program);
+
+			const agentCommand = program.commands.find(
+				cmd => cmd.name() === "agent"
+			);
+			const subCommands = agentCommand?.commands || [];
+			const removeCommand = subCommands.find(
+				cmd => cmd.name() === "remove"
+			);
+
+			expect(removeCommand).toBeDefined();
+			expect(removeCommand?.description()).toBe("Remove an AI agent");
+
+			// Check options
+			const options = removeCommand?.options || [];
+			const agentOption = options.find(opt => opt.long === "--agent");
+			const projectOption = options.find(opt => opt.long === "--project");
+
+			expect(agentOption).toBeDefined();
+			expect(projectOption).toBeDefined();
+		});
+
+		it("should register agent deploy subcommand", () => {
+			registerAgentCommands(program);
+
+			const agentCommand = program.commands.find(
+				cmd => cmd.name() === "agent"
+			);
+			const subCommands = agentCommand?.commands || [];
+			const deployCommand = subCommands.find(
+				cmd => cmd.name() === "deploy"
+			);
+
+			expect(deployCommand).toBeDefined();
+			expect(deployCommand?.description()).toBe(
+				"Deploy an AI agent to the Nestbox platform"
+			);
+
+			// Check options
+			const options = deployCommand?.options || [];
+			const projectOption = options.find(opt => opt.long === "--project");
+			const agentOption = options.find(opt => opt.long === "--agent");
+			const instanceOption = options.find(
+				opt => opt.long === "--instance"
+			);
+
+			expect(projectOption).toBeDefined();
+			expect(agentOption).toBeDefined();
+			expect(instanceOption).toBeDefined();
+		});
+
+		it("should register agent create subcommand", () => {
+			registerAgentCommands(program);
+
+			const agentCommand = program.commands.find(
+				cmd => cmd.name() === "agent"
+			);
+			const subCommands = agentCommand?.commands || [];
+			const createCommand = subCommands.find(
+				cmd => cmd.name() === "create"
+			);
+
+			expect(createCommand).toBeDefined();
+			expect(createCommand?.description()).toBe(
+				"Create an agent with direct arguments or YAML."
+			);
+
+			// Check that it has optional arguments (in command name: "create [firstArg] [secondArg]")
+			expect(createCommand?.name()).toBe("create");
+
+			// Check options
+			const options = createCommand?.options || [];
+			const projectOption = options.find(opt => opt.long === "--project");
+
+			expect(projectOption).toBeDefined();
+		});
+
+		it("should have all expected agent subcommands", () => {
+			registerAgentCommands(program);
+
+			const agentCommand = program.commands.find(
+				cmd => cmd.name() === "agent"
+			);
+			const subCommandNames =
+				agentCommand?.commands.map(cmd => cmd.name()) || [];
+
+			expect(subCommandNames).toContain("list");
+			expect(subCommandNames).toContain("remove");
+			expect(subCommandNames).toContain("deploy");
+			expect(subCommandNames).toContain("create");
+			expect(subCommandNames).toHaveLength(4);
+		});
+
+		it("should have proper action functions for all subcommands", () => {
+			registerAgentCommands(program);
+
+			const agentCommand = program.commands.find(
+				cmd => cmd.name() === "agent"
+			);
+			const subCommands = agentCommand?.commands || [];
+
+			subCommands.forEach(cmd => {
+				expect(typeof cmd.action).toBe("function");
+			});
+		});
+	});
 });

package/dist/commands/agent/createFromYaml.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function registerCreateFromYamlCommand(agentCommand: Command): void;