@nestbox-ai/cli 1.0.48 → 1.0.49

package/templates/chatbot-js/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "chatbot",
-  "version": "1.0.0",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC",
-  "description": "",
-  "dependencies": {
-    "@nestbox-ai/functions": "^2.0.0",
-    "ollama": "^0.5.14"
-  }
-}

package/templates/chatbot-py/main.py.hbs

@@ -1,42 +0,0 @@
-from nestbox_ai_functions import use_chatbot
-from openai import OpenAI
-
-MODEL_NAME = "openai/gpt-oss-20b"
-
-client = OpenAI(
-    base_url="http://localhost:8000/v1",
-    api_key="sk-xxxxxx"
-)
-
-@use_chatbot
-async def {{agentName}}(context, events):
-    try:
-        response = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=context.messages,
-            stream=False,
-        )
-
-        result = (
-            response.choices[0].message.content
-            if response.choices
-            else None
-        )
-
-        if not result:
-            await events.emitQueryFailed({
-                "data": {
-                    "error": "No response from model"
-                }
-            })
-        else:
-            await events.emitQueryCompleted({
-                "data": result
-            })
-
-    except Exception as e:
-        await events.emitQueryFailed({
-            "data": {
-                "error": str(e)
-            }
-        })

package/templates/chatbot-py/nestbox-agents.yaml.hbs

@@ -1,12 +0,0 @@
-agents:
-  - name: {{ agentNameInYaml }}
-    description: Our new agent {{ agentNameInYaml }} that uses the nestbox API
-    entry: {{agentName}}
-    inputSchema:
-      type: object
-      properties:
-        content:
-          type: string
-          description: The content of the input as string
-          minLength: 10
-          maxLength: 5000

package/templates/chatbot-py/pyproject.toml

@@ -1,19 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "app"
-version = "1.0.0"
-description = "Nestbox AI Python Agent"
-requires-python = ">=3.9"
-
-dependencies = [
-    "nestbox-ai-functions>=2.0.3",
-    "openai>=1.40.0",
-    "httpx>=0.27.0",
-    "anyio>=4.0.0"
-]
-
-[tool.setuptools]
-packages = ["."]

package/templates/chatbot-ts/eslint.config.mjs

@@ -1,27 +0,0 @@
-import tsParser from "@typescript-eslint/parser";
-import eslintPluginTs from "@typescript-eslint/eslint-plugin";
-
-export default [
-  {
-    files: ["**/*.ts"],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module",
-      },
-    },
-    plugins: {
-      "@typescript-eslint": eslintPluginTs,
-    },
-    rules: {
-      ...eslintPluginTs.configs.recommended.rules,
-      // Optional custom rules:
-      // '@typescript-eslint/no-explicit-any': 'warn',
-      // '@typescript-eslint/explicit-function-return-type': 'off',
-    },
-  },
-  {
-    ignores: ["dist/", "node_modules/"],
-  },
-];

package/templates/chatbot-ts/package.json

@@ -1,24 +0,0 @@
-{
-  "name": "app-ts",
-  "version": "1.0.0",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "ts-node src/index.ts",
-    "lint": "eslint ."
-  },
-  "author": "",
-  "license": "ISC",
-  "description": "",
-  "dependencies": {
-    "@nestbox-ai/functions": "^2.0.0",
-    "ollama": "^0.5.15"
-  },
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^8.31.0",
-    "@typescript-eslint/parser": "^8.31.0",
-    "eslint": "^9.25.1",
-    "typescript": "^5.8.3"
-  }
-}

package/templates/chatbot-ts/src/index.ts.hbs

@@ -1,18 +0,0 @@
-import { ChatContext, ChatEvents, useChatbot } from "@nestbox-ai/functions";
-import { Ollama } from "ollama";
-
-const ollama = new Ollama();
-
-export const {{agentName}} = useChatbot(
-  async (context: ChatContext, events: ChatEvents) => {
-    const response = await ollama.chat({
-      messages: context.messages,
-      model: "gemma3:27b",
-      stream: false,
-    });
-    const result = response.response;
-
-    events.emitQueryCompleted({ data: result });
-  }
-);
-

package/templates/chatbot-ts/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts"],
-}

package/test/README.md

@@ -1,52 +0,0 @@
-# Test Suite Summary
-
-This directory contains comprehensive unit tests for all CLI commands in the nestbox-ai-cli-tools project.
-
-## Test Files Created
-
-- **auth.test.ts** - Tests for authentication commands (login, logout)
-- **projects.test.ts** - Tests for project management commands (project use, project add, list)
-- **compute.test.ts** - Tests for compute instance management commands (compute list, create, delete)
-- **document.test.ts** - Tests for document management commands (doc and collection subcommands)
-- **image.test.ts** - Tests for image management commands (image list)
-- **agent.test.ts** - Tests for agent management commands (agent list, remove, deploy, generate, create)
-
-## What the Tests Cover
-
-Each test file verifies:
-
-1. **Command Registration** - Ensures all commands and subcommands are properly registered
-2. **Command Structure** - Validates command names, descriptions, and hierarchy
-3. **Options and Arguments** - Checks that expected command-line options are available
-4. **Action Functions** - Verifies that action handlers are properly attached
-
-## Test Strategy
-
-The tests focus on **command registration and structure validation** rather than execution logic. This approach:
-
-- Ensures the CLI interface remains stable
-- Validates command-line argument parsing
-- Verifies help text and descriptions
-- Doesn't require mocking complex external APIs
-- Runs quickly and reliably
-
-## Running Tests
-
-```bash
-# Run all tests
-npm test
-
-# Run tests with coverage
-npm run coverage
-
-# Run specific test file
-npm test auth.test.ts
-```
-
-## Test Framework
-
-- **Vitest** - Fast unit test runner with TypeScript support
-- **Commander.js** - CLI framework being tested
-- **Mock Strategy** - External dependencies are mocked to isolate command registration logic
-
-All tests are passing and provide confidence that the CLI command structure is working correctly.

package/test/agent.test.ts

@@ -1,154 +0,0 @@
-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/test/auth.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerAuthCommands } from '../src/commands/auth';
-
-describe('Auth Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerAuthCommands', () => {
-    it('should register login command with correct parameters', () => {
-      registerAuthCommands(program);
-
-      const commands = program.commands;
-      const loginCommand = commands.find(cmd => cmd.name() === 'login');
-
-      expect(loginCommand).toBeDefined();
-      expect(loginCommand?.description()).toBe('Login using Google SSO');
-      
-      // Check if the command expects a domain argument (it's in the command name)
-      expect(loginCommand?.name()).toBe('login');
-    });
-
-    it('should register logout command with correct parameters', () => {
-      registerAuthCommands(program);
-
-      const commands = program.commands;
-      const logoutCommand = commands.find(cmd => cmd.name() === 'logout');
-
-      expect(logoutCommand).toBeDefined();
-      expect(logoutCommand?.description()).toBe('Logout from Nestbox platform');
-      
-      // Check if the command has an optional domain argument (it's in the command name)
-      expect(logoutCommand?.name()).toBe('logout');
-    });
-
-    it('should register all expected auth commands', () => {
-      registerAuthCommands(program);
-
-      const commandNames = program.commands.map(cmd => cmd.name());
-      expect(commandNames).toContain('login');
-      expect(commandNames).toContain('logout');
-      expect(commandNames).toHaveLength(2);
-    });
-
-    it('should have proper command structure for login', () => {
-      registerAuthCommands(program);
-
-      const loginCommand = program.commands.find(cmd => cmd.name() === 'login');
-      
-      // Verify command properties
-      expect(loginCommand?.name()).toBe('login');
-      expect(loginCommand?.description()).toBe('Login using Google SSO');
-      expect(typeof loginCommand?.action).toBe('function');
-    });
-
-    it('should have proper command structure for logout', () => {
-      registerAuthCommands(program);
-
-      const logoutCommand = program.commands.find(cmd => cmd.name() === 'logout');
-      
-      // Verify command properties
-      expect(logoutCommand?.name()).toBe('logout');
-      expect(logoutCommand?.description()).toBe('Logout from Nestbox platform');
-      expect(typeof logoutCommand?.action).toBe('function');
-    });
-  });
-});

package/test/compute.test.ts

@@ -1,135 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerComputeProgram } from '../src/commands/compute';
-
-describe('Compute Commands', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    vi.clearAllMocks();
-  });
-
-  describe('registerComputeProgram', () => {
-    it('should register compute command group', () => {
-      registerComputeProgram(program);
-
-      const commands = program.commands;
-      const computeCommand = commands.find(cmd => cmd.name() === 'compute');
-
-      expect(computeCommand).toBeDefined();
-      expect(computeCommand?.description()).toBe('Manage Nestbox computes');
-    });
-
-    it('should register compute list subcommand', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const subCommands = computeCommand?.commands || [];
-      const listCommand = subCommands.find(cmd => cmd.name() === 'list');
-
-      expect(listCommand).toBeDefined();
-      expect(listCommand?.description()).toBe('List all compute instances');
-      
-      // Check options
-      const options = listCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      expect(projectOption).toBeDefined();
-      expect(projectOption?.description).toBe('Project ID or name (defaults to the current project)');
-    });
-
-    it('should register compute create subcommand', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const subCommands = computeCommand?.commands || [];
-      const createCommand = subCommands.find(cmd => cmd.name() === 'create');
-
-      expect(createCommand).toBeDefined();
-      expect(createCommand?.description()).toBe('Create a new compute instance');
-      
-      // Check options
-      const options = createCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      const imageOption = options.find(opt => opt.long === '--image');
-      
-      expect(projectOption).toBeDefined();
-      expect(imageOption).toBeDefined();
-    });
-
-    it('should register compute delete subcommand', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const subCommands = computeCommand?.commands || [];
-      const deleteCommand = subCommands.find(cmd => cmd.name() === 'delete');
-
-      expect(deleteCommand).toBeDefined();
-      expect(deleteCommand?.description()).toBe('Delete one or more compute instances');
-      
-      // Check options
-      const options = deleteCommand?.options || [];
-      const projectOption = options.find(opt => opt.long === '--project');
-      const forceOption = options.find(opt => opt.long === '--force');
-      
-      expect(projectOption).toBeDefined();
-      expect(forceOption).toBeDefined();
-    });
-
-    it('should have all expected compute subcommands', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const subCommandNames = computeCommand?.commands.map(cmd => cmd.name()) || [];
-      
-      expect(subCommandNames).toContain('list');
-      expect(subCommandNames).toContain('create');
-      expect(subCommandNames).toContain('delete');
-      expect(subCommandNames).toHaveLength(3);
-    });
-
-    it('should have proper action functions for all subcommands', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const subCommands = computeCommand?.commands || [];
-      
-      subCommands.forEach(cmd => {
-        expect(typeof cmd.action).toBe('function');
-      });
-    });
-
-    it('should register compute list command with correct structure', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const listCommand = computeCommand?.commands.find(cmd => cmd.name() === 'list');
-      
-      expect(listCommand?.name()).toBe('list');
-      expect(listCommand?.description()).toBe('List all compute instances');
-      expect(typeof listCommand?.action).toBe('function');
-    });
-
-    it('should register compute create command with correct structure', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const createCommand = computeCommand?.commands.find(cmd => cmd.name() === 'create');
-      
-      expect(createCommand?.name()).toBe('create');
-      expect(createCommand?.description()).toBe('Create a new compute instance');
-      expect(typeof createCommand?.action).toBe('function');
-    });
-
-    it('should register compute delete command with correct structure', () => {
-      registerComputeProgram(program);
-
-      const computeCommand = program.commands.find(cmd => cmd.name() === 'compute');
-      const deleteCommand = computeCommand?.commands.find(cmd => cmd.name() === 'delete');
-      
-      expect(deleteCommand?.name()).toBe('delete');
-      expect(deleteCommand?.description()).toBe('Delete one or more compute instances');
-      expect(typeof deleteCommand?.action).toBe('function');
-    });
-  });
-});