newo 2.0.6 → 3.1.0

package/README.md

@@ -8,6 +8,7 @@
 **NEWO CLI** - Professional command-line tool for NEWO AI Agent development. Features **modular architecture**, **IDN-based file management**, and **comprehensive multi-customer support**.
 
 Sync NEWO "Project → Agent → Flow → Skills" structure to local files with:
+- 🏗️ **Complete entity management** - Create, edit, and delete agents, flows, skills, events, and states (NEW v2.0+)
 - 🔄 **Intelligent synchronization** - Pull projects, attributes, and conversations automatically
 - 🎯 **IDN-based naming** - Skills named as `{skillIdn}.jinja/.guidance` for better organization
 - 📊 **Real-time progress** - Live progress tracking during large operations (966+ skills)
@@ -19,6 +20,7 @@ Sync NEWO "Project → Agent → Flow → Skills" structure to local files with:
 - 🧠 **AI skill formats** - Support for `.guidance` (AI prompts) and `.jinja` (NSL templates)
 - 📊 **Knowledge base import** - Bulk import AKB articles from structured text files
 - 💬 **Conversation history** - Extract and sync user conversations and personas
+- 🧪 **Sandbox testing** - Interactive agent testing with conversation continuation (NEW v3.1.0)
 - 🔧 **CI/CD ready** - GitHub Actions integration for automated deployments
 
 ---
@@ -59,6 +61,13 @@ npm install && npm run build
    newo status  # See what's modified
    ```
 
+4. **Create entities** (NEW v2.0+):
+   ```bash
+   newo create-agent MyBot --project <project-idn>    # Create agent locally
+   newo create-flow MainFlow --agent MyBot --project <project-idn>  # Create flow
+   newo push && newo pull   # Sync to platform
+   ```
+
 ---
 
 ## Configuration
@@ -134,11 +143,43 @@ NEWO_REFRESH_URL=custom_refresh_endpoint   # Custom refresh endpoint
 | `newo pull` | Download projects + attributes + metadata | • Real-time progress tracking (966+ skills)<br>• IDN-based file naming<br>• Automatic attributes.yaml generation<br>• `--force` for silent overwrite |
 | `newo push` | Upload local changes to NEWO | • Smart file validation<br>• Multiple file detection<br>• Hash-based change detection<br>• Safe error handling |
 | `newo status` | Show modified files with details | • Multiple file warnings<br>• Detailed change analysis<br>• Clean state validation<br>• Per-customer status |
+| `newo sandbox` | Test agents in sandbox chat mode | • Single-command mode for automation<br>• Multi-turn conversation support<br>• Debug info for agent development<br>• Conversation continuation |
 | `newo conversations` | Pull conversation history | • User personas and chat history<br>• YAML format output<br>• Pagination support |
 | `newo list-customers` | List configured customers | • Shows default customer<br>• Multi-customer discovery |
 | `newo import-akb` | Import knowledge base articles | • Structured text parsing<br>• Bulk article import<br>• Validation and error reporting |
 | `newo meta` | Get project metadata (debug) | • Project structure analysis<br>• Metadata validation |
 
+### Entity Management Commands
+
+**Complete lifecycle management for NEWO entities with local-first workflow:**
+
+| Command | Description | Features |
+|---------|-------------|----------|
+| **Project Management** |||
+| `newo create-project <idn>` | Create new project on platform | • Automatic project initialization<br>• Metadata configuration<br>• Version control support |
+| **Agent Management** |||
+| `newo create-agent <idn> --project <pid>` | Create agent locally | • Local folder structure<br>• Metadata generation<br>• Persona assignment support |
+| `newo delete-agent <aid> --project <pid> --confirm` | Delete agent locally | • Safety confirmation required<br>• Local-only deletion<br>• Push to sync platform |
+| **Flow Management** |||
+| `newo create-flow <idn> --agent <aid> --project <pid>` | Create flow locally | • Guidance/NSL runner selection<br>• Automatic metadata<br>• Push to platform |
+| `newo delete-flow <fid> --agent <aid> --project <pid> --confirm` | Delete flow locally | • Safety confirmation required<br>• Local-only deletion<br>• Push to sync platform |
+| **Skill Management** |||
+| `newo create-skill <idn> --flow <fid> --agent <aid> --project <pid>` | Create skill locally | • Script content initialization<br>• Runner type selection<br>• Parameter support |
+| `newo delete-skill <sid> --flow <fid> --agent <aid> --project <pid> --confirm` | Delete skill locally | • Safety confirmation required<br>• Local-only deletion<br>• Push to sync platform |
+| **Advanced Components (NSL)** |||
+| `newo create-event <idn> --flow <fid>` | Create flow event | • Integration point setup<br>• Skill selector config<br>• Interrupt mode control |
+| `newo create-state <idn> --flow <fid>` | Create flow state field | • User/flow/global scope<br>• Default value config<br>• State persistence |
+| `newo create-parameter <name> --skill <sid>` | Create skill parameter | • Default value support<br>• Type configuration<br>• Parameter metadata |
+| **Identity & Configuration** |||
+| `newo create-persona <name>` | Create agent persona | • Persona configuration<br>• Title and description<br>• Agent assignment |
+| `newo create-attribute <idn> --value <val>` | Create customer attribute | • Enum types support<br>• Group organization<br>• Hidden attributes |
+
+**Workflow:**
+1. **Create locally** → Entities created as folder structures with metadata.yaml
+2. **Edit content** → Modify scripts, metadata, and configuration files
+3. **Push to platform** → `newo push` automatically detects and creates entities on NEWO
+4. **Sync complete** → `newo pull` retrieves IDs and platform-generated data
+
 ### Multi-Customer Commands
 
 ```bash
@@ -246,6 +287,16 @@ newo_customers/                         # Root folder for all customers
 - **Project structure export** - `flows.yaml` for external tooling integration
 - **Cross-project operations** - Commands work across entire workspace
 
+### 🏗️ Complete Entity Management (NEW v2.0+)
+- **Local-first workflow** - Create entities locally, push to platform when ready
+- **Full lifecycle support** - Create, edit, delete agents, flows, skills, events, states
+- **Automatic detection** - Push command auto-detects local-only entities
+- **Safe deletion** - Confirmation flags prevent accidental deletions
+- **Hierarchical creation** - Maintains proper agent → flow → skill relationships
+- **NSL component support** - Create events, states, and parameters for NSL flows
+- **Identity management** - Persona and attribute creation and configuration
+- **Project scaffolding** - Complete project initialization from CLI
+
 ### 🔄 Intelligent Synchronization
 - **Two-way sync** - Pull from NEWO platform, push local changes back
 - **Change detection** - SHA256 hashing prevents unnecessary uploads
@@ -427,6 +478,107 @@ Add these secrets to your repository:
     node ./dist/cli.js push
 ```
 
+## Sandbox Testing (NEW v3.1.0)
+
+Test your NEWO agents in real-time with sandbox chat mode. Perfect for development, debugging, and automated testing workflows.
+
+### Features
+- **Single-command mode** - Send a message and get a response (ideal for automation)
+- **Multi-turn conversations** - Continue chats with conversation context preserved
+- **Debug information** - View flow execution, skill invocation, and session tracking
+- **Unique sessions** - Each test creates a fresh persona for isolation
+
+### Usage
+
+**Start a new conversation:**
+```bash
+newo sandbox "Hello, I want to order a pizza"
+```
+
+**Continue an existing conversation:**
+```bash
+newo sandbox --actor <chat-id> "I want 2 large pepperoni pizzas"
+```
+
+**With verbose debugging:**
+```bash
+newo sandbox "Test message" --verbose
+```
+
+### Example: Multi-Turn Conversation
+
+```bash
+# Turn 1: Start conversation
+$ newo sandbox "I want to order delivery"
+
+📋 Chat Session Created:
+   Chat ID (actor_id): abc123...
+   Persona ID: xyz789...
+   Connector: convo_agent_sandbox
+   External ID: 2f99f7
+
+📤 You: I want to order delivery
+
+🤖 Agent:
+   Awesome! We can definitely get a delivery order started for you! What's your zip code, please?
+
+📊 Debug Summary:
+   Flow: CAMainFlow
+   Skill: _userMessageFastReplySkill
+   Session: 816c769a-8e1c-43e7-b22d-766c7bf63c33
+   Acts Processed: 1 (1 agent, 0 system)
+
+💡 To continue this conversation:
+   npx newo sandbox --actor abc123... "your next message"
+
+
+# Turn 2: Continue conversation
+$ newo sandbox --actor abc123... "90210"
+
+📤 You: 90210
+
+🤖 Agent:
+   Perfect! Now, could you please provide your delivery address?
+
+📊 Debug Summary:
+   Flow: CAMainFlow
+   Skill: CollectAddressSkill
+   Session: 816c769a-8e1c-43e7-b22d-766c7bf63c33
+   Acts Processed: 1 (1 agent, 0 user)
+```
+
+### Debug Information
+
+**Standard Mode** shows:
+- Flow execution path
+- Skill invocation
+- Session ID
+- Act counts (agent vs. system messages)
+
+**Verbose Mode** (`--verbose`) shows:
+- All API requests and responses
+- Complete act structure with arguments
+- Runtime context IDs
+- Detailed polling progress
+
+### Automated Testing Integration
+
+Perfect for CI/CD workflows:
+
+```bash
+# Test agent responses
+RESPONSE=$(newo sandbox "test query" | grep "Agent:" | cut -d: -f2-)
+
+# Validate response contains expected content
+echo "$RESPONSE" | grep -q "expected text" && echo "✓ Test passed"
+
+# Multi-turn testing
+ACTOR_ID=$(newo sandbox "start conversation" | grep "Chat ID" | awk '{print $NF}')
+newo sandbox --actor "$ACTOR_ID" "follow up message"
+```
+
+---
+
 ## AKB Import
 
 Import knowledge base articles from structured text files into NEWO personas:
@@ -502,6 +654,80 @@ newo import-akb articles.txt da4550db-2b95-4500-91ff-fb4b60fe7be9
 newo import-akb articles.txt persona_id --verbose
 ```
 
+### Entity Creation Workflows
+
+**Complete Weather System Example (End-to-End):**
+
+```bash
+# Step 1: Create project infrastructure
+newo create-project weather_system --title "Weather System" --description "Comprehensive weather service"
+newo pull  # Sync new project locally
+
+# Step 2: Create persona and configuration
+newo create-persona weather_persona --title "Weather Assistant" --description "Professional weather guidance"
+newo create-attribute weather_api_key --value "your_api_key" --group "Weather Config"
+
+# Step 3: Create agent structure
+newo create-agent WeatherBot --project weather_system --title "Weather Bot" --persona-id <persona-id>
+newo push && newo pull  # Push to platform, sync IDs
+
+# Step 4: Create flow and skills
+newo create-flow MainFlow --agent WeatherBot --project weather_system --title "Main Flow" --runner nsl
+newo push && newo pull  # Sync flow ID
+
+newo create-skill WeatherSkill --flow MainFlow --agent WeatherBot --project weather_system \
+  --title "Weather NSL Skill" --runner nsl --script "Welcome to weather service!"
+
+# Step 5: Add NSL components
+newo create-event user_message --flow <flow-id> --skill WeatherSkill --integration api --connector webhook
+newo create-state user_location --flow <flow-id> --title "User Location" --scope user
+newo create-state request_count --flow <flow-id> --title "Request Count" --scope flow
+
+# Step 6: Final sync
+newo push  # Creates complete system
+newo status  # Should show: Clean
+```
+
+**Quick Agent Creation:**
+
+```bash
+# Create complete agent structure
+newo pull  # Ensure local projects are synced
+newo create-agent SupportBot --project my_project --title "Support Bot"
+newo create-flow HelpFlow --agent SupportBot --project my_project --title "Help Flow"
+newo push && newo pull  # Sync to platform
+
+newo create-skill Greeting --flow HelpFlow --agent SupportBot --project my_project \
+  --title "Greeting Skill" --runner guidance
+newo push  # Deploy to platform
+```
+
+**Local Development & Testing:**
+
+```bash
+# Create locally, test before pushing
+newo create-agent TestBot --project my_project
+newo create-flow TestFlow --agent TestBot --project my_project
+
+# Edit metadata and scripts locally in your IDE
+# newo_customers/CUSTOMER_IDN/projects/my_project/TestBot/TestFlow/
+
+newo status  # Check changes
+newo push  # Deploy when ready
+```
+
+**Entity Deletion:**
+
+```bash
+# Delete with safety confirmation
+newo delete-skill OldSkill --flow MainFlow --agent SupportBot --project my_project --confirm
+newo delete-flow OldFlow --agent SupportBot --project my_project --confirm
+newo delete-agent OldBot --project my_project --confirm
+
+# Push to sync deletions to platform
+newo push
+```
+
 ---
 
 ## Development
@@ -951,6 +1177,37 @@ NEWO CLI integrates with these NEWO platform endpoints:
 - `GET /api/v1/designer/flows/{flowId}/events` - List flow events
 - `GET /api/v1/designer/flows/{flowId}/states` - List flow states
 
+### Entity Creation & Deletion (NEW v2.0+)
+- `POST /api/v2/designer/{projectId}/agents` - Create new agent
+- `DELETE /api/v1/designer/agents/{agentId}` - Delete agent
+- `POST /api/v1/designer/{agentId}/flows/empty` - Create new flow
+- `DELETE /api/v1/designer/flows/{flowId}` - Delete flow
+- `POST /api/v1/designer/flows/{flowId}/skills` - Create new skill
+- `DELETE /api/v1/designer/flows/skills/{skillId}` - Delete skill
+- `POST /api/v1/designer/flows/{flowId}/events` - Create flow event
+- `DELETE /api/v1/designer/flows/events/{eventId}` - Delete flow event
+- `POST /api/v1/designer/flows/{flowId}/states` - Create flow state
+- `POST /api/v1/designer/flows/skills/{skillId}/parameters` - Create skill parameter
+- `POST /api/v1/customer/attributes` - Create customer attribute
+- `POST /api/v1/designer/personas` - Create agent persona
+- `POST /api/v1/designer/projects` - Create project
+- `POST /api/v1/designer/flows/{flowId}/publish` - Publish flow
+
+### Conversations & Attributes
+- `GET /api/v1/bff/conversations/user-personas` - List user personas
+- `GET /api/v1/chat/history` - Get conversation history
+- `GET /api/v1/bff/conversations/acts` - Get conversation acts (fallback)
+- `GET /api/v1/bff/customer/attributes?include_hidden=true` - Get customer attributes
+- `PUT /api/v1/customer/attributes/{attributeId}` - Update customer attribute
+
+### Sandbox Testing (NEW v3.1.0)
+- `GET /api/v1/integrations` - List available integrations
+- `GET /api/v1/integrations/{id}/connectors` - List integration connectors
+- `POST /api/v1/customer/personas` - Create user persona for chat
+- `POST /api/v1/customer/personas/{id}/actors` - Create actor (chat session)
+- `POST /api/v1/chat/user/{actorId}` - Send chat message
+- `GET /api/v1/chat/history` - Poll for agent responses
+
 ### Knowledge Base
 - `POST /api/v1/akb/append-manual` - Import AKB articles to persona
 

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { type AxiosInstance } from 'axios';
-import type { ProjectMeta, Agent, Skill, FlowEvent, FlowState, AkbImportArticle, CustomerProfile, CustomerAttribute, CustomerAttributesResponse, UserPersonaResponse, UserPersona, ChatHistoryParams, ChatHistoryResponse } from './types.js';
+import type { ProjectMeta, Agent, Skill, FlowEvent, FlowState, AkbImportArticle, CustomerProfile, CustomerAttribute, CustomerAttributesResponse, UserPersonaResponse, UserPersona, ChatHistoryParams, ChatHistoryResponse, CreateAgentRequest, CreateAgentResponse, CreateFlowRequest, CreateFlowResponse, CreateSkillRequest, CreateSkillResponse, CreateFlowEventRequest, CreateFlowEventResponse, CreateFlowStateRequest, CreateFlowStateResponse, CreateSkillParameterRequest, CreateSkillParameterResponse, CreateCustomerAttributeRequest, CreateCustomerAttributeResponse, CreatePersonaRequest, CreatePersonaResponse, CreateProjectRequest, CreateProjectResponse, PublishFlowRequest, PublishFlowResponse, Integration, Connector, CreateSandboxPersonaRequest, CreateSandboxPersonaResponse, CreateActorRequest, CreateActorResponse, SendChatMessageRequest, ConversationActsParams, ConversationActsResponse } from './types.js';
 export declare function makeClient(verbose?: boolean, token?: string): Promise<AxiosInstance>;
 export declare function listProjects(client: AxiosInstance): Promise<ProjectMeta[]>;
 export declare function listAgents(client: AxiosInstance, projectId: string): Promise<Agent[]>;
@@ -20,4 +20,26 @@ export declare function getAccount(client: AxiosInstance): Promise<{
     [key: string]: any;
 }>;
 export declare function getChatHistory(client: AxiosInstance, params: ChatHistoryParams): Promise<ChatHistoryResponse>;
+export declare function createAgent(client: AxiosInstance, projectId: string, agentData: CreateAgentRequest): Promise<CreateAgentResponse>;
+export declare function deleteAgent(client: AxiosInstance, agentId: string): Promise<void>;
+export declare function createFlow(client: AxiosInstance, agentId: string, flowData: CreateFlowRequest): Promise<CreateFlowResponse>;
+export declare function deleteFlow(client: AxiosInstance, flowId: string): Promise<void>;
+export declare function createSkill(client: AxiosInstance, flowId: string, skillData: CreateSkillRequest): Promise<CreateSkillResponse>;
+export declare function deleteSkill(client: AxiosInstance, skillId: string): Promise<void>;
+export declare function deleteSkillById(client: AxiosInstance, skillId: string): Promise<void>;
+export declare function createFlowEvent(client: AxiosInstance, flowId: string, eventData: CreateFlowEventRequest): Promise<CreateFlowEventResponse>;
+export declare function deleteFlowEvent(client: AxiosInstance, eventId: string): Promise<void>;
+export declare function createFlowState(client: AxiosInstance, flowId: string, stateData: CreateFlowStateRequest): Promise<CreateFlowStateResponse>;
+export declare function createSkillParameter(client: AxiosInstance, skillId: string, paramData: CreateSkillParameterRequest): Promise<CreateSkillParameterResponse>;
+export declare function createCustomerAttribute(client: AxiosInstance, attributeData: CreateCustomerAttributeRequest): Promise<CreateCustomerAttributeResponse>;
+export declare function createProject(client: AxiosInstance, projectData: CreateProjectRequest): Promise<CreateProjectResponse>;
+export declare function deleteProject(client: AxiosInstance, projectId: string): Promise<void>;
+export declare function createPersona(client: AxiosInstance, personaData: CreatePersonaRequest): Promise<CreatePersonaResponse>;
+export declare function publishFlow(client: AxiosInstance, flowId: string, publishData: PublishFlowRequest): Promise<PublishFlowResponse>;
+export declare function listIntegrations(client: AxiosInstance): Promise<Integration[]>;
+export declare function listConnectors(client: AxiosInstance, integrationId: string): Promise<Connector[]>;
+export declare function createSandboxPersona(client: AxiosInstance, personaData: CreateSandboxPersonaRequest): Promise<CreateSandboxPersonaResponse>;
+export declare function createActor(client: AxiosInstance, personaId: string, actorData: CreateActorRequest): Promise<CreateActorResponse>;
+export declare function sendChatMessage(client: AxiosInstance, actorId: string, messageData: SendChatMessageRequest): Promise<void>;
+export declare function getConversationActs(client: AxiosInstance, params: ConversationActsParams): Promise<ConversationActsResponse>;
 //# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -151,4 +151,118 @@ export async function getChatHistory(client, params) {
     });
     return response.data;
 }
+// Entity Creation/Deletion API Functions
+export async function createAgent(client, projectId, agentData) {
+    // Use project-specific v2 endpoint for proper project association
+    const response = await client.post(`/api/v2/designer/${projectId}/agents`, agentData);
+    return response.data;
+}
+export async function deleteAgent(client, agentId) {
+    await client.delete(`/api/v1/designer/agents/${agentId}`);
+}
+export async function createFlow(client, agentId, flowData) {
+    // Use the correct NEWO endpoint pattern for flow creation
+    const response = await client.post(`/api/v1/designer/${agentId}/flows/empty`, flowData);
+    // The NEWO flow creation API returns empty response body with 201 status
+    // The flow is created successfully, but we need to get the ID through agent listing
+    if (response.status === 201) {
+        // Flow created successfully, but ID will be retrieved during pull operation
+        return { id: 'pending-sync' };
+    }
+    throw new Error(`Flow creation failed with status: ${response.status}`);
+}
+export async function deleteFlow(client, flowId) {
+    await client.delete(`/api/v1/designer/flows/${flowId}`);
+}
+export async function createSkill(client, flowId, skillData) {
+    const response = await client.post(`/api/v1/designer/flows/${flowId}/skills`, skillData);
+    return response.data;
+}
+export async function deleteSkill(client, skillId) {
+    await client.delete(`/api/v1/designer/flows/skills/${skillId}`);
+}
+export async function deleteSkillById(client, skillId) {
+    console.log(`🗑️ Deleting skill from platform: ${skillId}`);
+    await client.delete(`/api/v1/designer/flows/skills/${skillId}`);
+    console.log(`✅ Skill deleted from platform: ${skillId}`);
+}
+export async function createFlowEvent(client, flowId, eventData) {
+    const response = await client.post(`/api/v1/designer/flows/${flowId}/events`, eventData);
+    return response.data;
+}
+export async function deleteFlowEvent(client, eventId) {
+    await client.delete(`/api/v1/designer/flows/events/${eventId}`);
+}
+export async function createFlowState(client, flowId, stateData) {
+    const response = await client.post(`/api/v1/designer/flows/${flowId}/states`, stateData);
+    return response.data;
+}
+export async function createSkillParameter(client, skillId, paramData) {
+    // Debug the parameter creation request
+    console.log('Creating parameter for skill:', skillId);
+    console.log('Parameter data:', JSON.stringify(paramData, null, 2));
+    try {
+        const response = await client.post(`/api/v1/designer/flows/skills/${skillId}/parameters`, paramData);
+        return response.data;
+    }
+    catch (error) {
+        console.error('Parameter creation error details:', error.response?.data);
+        throw error;
+    }
+}
+export async function createCustomerAttribute(client, attributeData) {
+    const response = await client.post('/api/v1/customer/attributes', attributeData);
+    return response.data;
+}
+export async function createProject(client, projectData) {
+    const response = await client.post('/api/v1/designer/projects', projectData);
+    return response.data;
+}
+export async function deleteProject(client, projectId) {
+    await client.delete(`/api/v1/designer/projects/${projectId}`);
+}
+export async function createPersona(client, personaData) {
+    const response = await client.post('/api/v1/customer/personas', personaData);
+    return response.data;
+}
+export async function publishFlow(client, flowId, publishData) {
+    const response = await client.post(`/api/v1/designer/flows/${flowId}/publish`, publishData);
+    return response.data;
+}
+// Sandbox Chat API Functions
+export async function listIntegrations(client) {
+    const response = await client.get('/api/v1/integrations');
+    return response.data;
+}
+export async function listConnectors(client, integrationId) {
+    const response = await client.get(`/api/v1/integrations/${integrationId}/connectors`);
+    return response.data;
+}
+export async function createSandboxPersona(client, personaData) {
+    const response = await client.post('/api/v1/customer/personas', personaData);
+    return response.data;
+}
+export async function createActor(client, personaId, actorData) {
+    const response = await client.post(`/api/v1/customer/personas/${personaId}/actors`, actorData);
+    return response.data;
+}
+export async function sendChatMessage(client, actorId, messageData) {
+    await client.post(`/api/v1/chat/user/${actorId}`, messageData);
+}
+export async function getConversationActs(client, params) {
+    const queryParams = {
+        user_persona_id: params.user_persona_id,
+        user_actor_id: params.user_actor_id,
+        per: params.per || 100,
+        page: params.page || 1
+    };
+    // Only add agent_persona_id if provided
+    if (params.agent_persona_id) {
+        queryParams.agent_persona_id = params.agent_persona_id;
+    }
+    const response = await client.get('/api/v1/bff/conversations/acts', {
+        params: queryParams
+    });
+    return response.data;
+}
 //# sourceMappingURL=api.js.map

package/dist/auth.js

@@ -48,6 +48,10 @@ function validateUrl(url, name) {
 }
 // Enhanced logging function
 function logAuthEvent(level, message, meta) {
+    // Skip all logging if in quiet mode
+    if (process.env.NEWO_QUIET_MODE === 'true') {
+        return;
+    }
     const timestamp = new Date().toISOString();
     const logEntry = {
         timestamp,

package/dist/cli/commands/create-agent.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleCreateAgentCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=create-agent.d.ts.map

package/dist/cli/commands/create-agent.js

@@ -0,0 +1,75 @@
+/**
+ * Create Agent Command Handler - Creates local folder structure
+ */
+import { requireSingleCustomer } from '../customer-selection.js';
+import { ensureState, agentMetadataPath, writeFileSafe, projectDir } from '../../fsutil.js';
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+export async function handleCreateAgentCommand(customerConfig, args, verbose = false) {
+    try {
+        const selectedCustomer = requireSingleCustomer(customerConfig, args.customer);
+        // Parse arguments
+        const idn = args._[1];
+        const title = args.title || idn;
+        const description = args.description || '';
+        const projectIdn = args.project;
+        const personaId = args['persona-id'];
+        if (!idn) {
+            console.error('Error: Agent IDN is required');
+            console.error('Usage: newo create-agent <idn> --project <project-idn> [--title <title>] [--description <description>] [--persona-id <persona-id>]');
+            process.exit(1);
+        }
+        if (!projectIdn) {
+            console.error('Error: Project IDN is required');
+            console.error('Usage: newo create-agent <idn> --project <project-idn> [--title <title>] [--description <description>] [--persona-id <persona-id>]');
+            process.exit(1);
+        }
+        // Ensure state directory exists
+        await ensureState(selectedCustomer.idn);
+        // Check if project exists locally
+        const projDir = projectDir(selectedCustomer.idn, projectIdn);
+        if (!(await fs.pathExists(projDir))) {
+            console.error(`❌ Project '${projectIdn}' not found locally. Run 'newo pull' first or check project IDN.`);
+            process.exit(1);
+        }
+        // Check if agent already exists
+        const agentDir = `${projDir}/${idn}`;
+        if (await fs.pathExists(agentDir)) {
+            console.error(`❌ Agent '${idn}' already exists in project '${projectIdn}'`);
+            process.exit(1);
+        }
+        if (verbose) {
+            console.log(`📝 Creating agent locally: ${idn}`);
+            console.log(`   Project: ${projectIdn}`);
+            console.log(`   Title: ${title}`);
+            console.log(`   Description: ${description}`);
+            console.log(`   Persona ID: ${personaId || 'none'}`);
+        }
+        // Create agent directory
+        await fs.ensureDir(agentDir);
+        // Create agent metadata
+        const agentMetadata = {
+            id: '', // Will be set during push
+            idn,
+            title,
+            description,
+            persona_id: personaId || null,
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString()
+        };
+        // Save agent metadata
+        const metadataPath = agentMetadataPath(selectedCustomer.idn, projectIdn, idn);
+        const metadataYaml = yaml.dump(agentMetadata, { indent: 2, quotingType: '"', forceQuotes: false });
+        await writeFileSafe(metadataPath, metadataYaml);
+        console.log(`✅ Agent created locally`);
+        console.log(`   IDN: ${idn}`);
+        console.log(`   Title: ${title}`);
+        console.log(`   Path: ${agentDir}`);
+        console.log(`   Run 'newo push' to create on NEWO platform`);
+    }
+    catch (error) {
+        console.error('❌ Failed to create agent locally:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=create-agent.js.map

package/dist/cli/commands/create-attribute.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleCreateAttributeCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=create-attribute.d.ts.map

package/dist/cli/commands/create-attribute.js

@@ -0,0 +1,63 @@
+/**
+ * Create Customer Attribute Command Handler
+ */
+import { makeClient, createCustomerAttribute } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { requireSingleCustomer } from '../customer-selection.js';
+export async function handleCreateAttributeCommand(customerConfig, args, verbose = false) {
+    try {
+        const selectedCustomer = requireSingleCustomer(customerConfig, args.customer);
+        // Parse arguments
+        const idn = args._[1];
+        const value = args.value || '';
+        const title = args.title || idn;
+        const description = args.description || '';
+        const group = args.group || 'General';
+        const isHidden = Boolean(args.hidden);
+        const valueType = args['value-type'] || 'string';
+        const possibleValues = args['possible-values'] ?
+            args['possible-values'].split(',').map(v => v.trim()) : [];
+        if (!idn) {
+            console.error('Error: Attribute IDN is required');
+            console.error('Usage: newo create-attribute <idn> --value <value> [--title <title>] [--description <desc>] [--group <group>] [--hidden] [--value-type <type>] [--possible-values <val1,val2>]');
+            process.exit(1);
+        }
+        if (!value) {
+            console.error('Error: Attribute value is required');
+            console.error('Usage: newo create-attribute <idn> --value <value> [options]');
+            process.exit(1);
+        }
+        if (verbose) {
+            console.log(`📝 Creating customer attribute: ${idn}`);
+            console.log(`   Title: ${title}`);
+            console.log(`   Value: ${value}`);
+            console.log(`   Group: ${group}`);
+            console.log(`   Type: ${valueType}`);
+            console.log(`   Hidden: ${isHidden}`);
+        }
+        // Get access token and create client
+        const accessToken = await getValidAccessToken(selectedCustomer);
+        const client = await makeClient(verbose, accessToken);
+        // Create attribute on NEWO platform
+        const createAttributeRequest = {
+            idn,
+            value,
+            title,
+            description,
+            group,
+            is_hidden: isHidden,
+            possible_values: possibleValues,
+            value_type: valueType
+        };
+        const createResponse = await createCustomerAttribute(client, createAttributeRequest);
+        console.log(`✅ Customer attribute created: ${idn} (ID: ${createResponse.id})`);
+        console.log(`   Title: ${title}`);
+        console.log(`   Value: ${value}`);
+        console.log(`   Group: ${group}`);
+    }
+    catch (error) {
+        console.error('❌ Failed to create customer attribute:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=create-attribute.js.map

package/dist/cli/commands/create-event.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleCreateEventCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=create-event.d.ts.map