newo 3.4.0 → 3.4.2

package/dist/cli/commands/diff.js

@@ -0,0 +1,288 @@
+/**
+ * Diff command handler
+ *
+ * Shows differences between local files and remote NEWO platform.
+ * Supports selective resource diffing with --only flag.
+ *
+ * Usage:
+ *   newo diff                      # Show all differences
+ *   newo diff --only projects      # Show only project differences
+ *   newo diff --detailed           # Show detailed content diff
+ */
+import { makeClient } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { selectSingleCustomer } from '../customer-selection.js';
+import { ALL_RESOURCE_TYPES } from '../../cli-new/di/tokens.js';
+import { getSkill, listAgents, listFlowSkills, getCustomerAttributes, listProjects } from '../../api.js';
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'js-yaml';
+/**
+ * Parse resource list from comma-separated string
+ */
+function parseResourceList(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim().toLowerCase()).filter(Boolean);
+}
+/**
+ * Color codes for terminal output
+ */
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+/**
+ * Generate unified diff output
+ */
+function generateUnifiedDiff(local, remote, filePath) {
+    const localLines = local.split('\n');
+    const remoteLines = remote.split('\n');
+    const output = [];
+    output.push(`${colors.cyan}--- local: ${filePath}${colors.reset}`);
+    output.push(`${colors.cyan}+++ remote: ${filePath}${colors.reset}`);
+    // Simple line-by-line comparison
+    const maxLines = Math.max(localLines.length, remoteLines.length);
+    let diffStart = -1;
+    let diffLines = [];
+    for (let i = 0; i < maxLines; i++) {
+        const localLine = localLines[i] ?? '';
+        const remoteLine = remoteLines[i] ?? '';
+        if (localLine !== remoteLine) {
+            if (diffStart === -1) {
+                diffStart = i + 1;
+            }
+            if (i < localLines.length) {
+                diffLines.push(`${colors.red}- ${localLine}${colors.reset}`);
+            }
+            if (i < remoteLines.length) {
+                diffLines.push(`${colors.green}+ ${remoteLine}${colors.reset}`);
+            }
+        }
+        else {
+            if (diffStart !== -1) {
+                output.push(`${colors.gray}@@ -${diffStart},${diffLines.length} @@${colors.reset}`);
+                output.push(...diffLines);
+                diffStart = -1;
+                diffLines = [];
+            }
+        }
+    }
+    if (diffLines.length > 0) {
+        output.push(`${colors.gray}@@ -${diffStart},${diffLines.length} @@${colors.reset}`);
+        output.push(...diffLines);
+    }
+    return output;
+}
+/**
+ * Get project differences
+ */
+async function getProjectDiffs(client, customer, _verbose) {
+    const diffs = [];
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    // Get all projects first
+    const projects = await listProjects(client);
+    for (const project of projects) {
+        const projectIdn = project.idn;
+        // Get all agents for this project
+        const agents = await listAgents(client, project.id);
+        for (const agent of agents) {
+            for (const flow of agent.flows || []) {
+                const skills = await listFlowSkills(client, flow.id);
+                for (const skill of skills) {
+                    // Get full skill content from API
+                    const remoteSkill = await getSkill(client, skill.id);
+                    const remoteContent = remoteSkill.prompt_script || '';
+                    // Determine local file path
+                    const extension = remoteSkill.runner_type === 'nsl' ? 'jinja' : 'guidance';
+                    const localPath = path.join(customerDir, 'projects', projectIdn, agent.idn, flow.idn, skill.idn, `${skill.idn}.${extension}`);
+                    // Compare with local
+                    if (await fs.pathExists(localPath)) {
+                        const localContent = await fs.readFile(localPath, 'utf-8');
+                        if (localContent !== remoteContent) {
+                            diffs.push({
+                                path: path.relative(process.cwd(), localPath),
+                                type: 'modified',
+                                localContent,
+                                remoteContent,
+                            });
+                        }
+                    }
+                    else {
+                        // File exists remotely but not locally
+                        diffs.push({
+                            path: path.relative(process.cwd(), localPath),
+                            type: 'deleted',
+                            remoteContent,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Check for local files that don't exist remotely
+    const projectsDir = path.join(customerDir, 'projects');
+    if (await fs.pathExists(projectsDir)) {
+        const walkDir = async (dir) => {
+            const files = [];
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    files.push(...await walkDir(fullPath));
+                }
+                else if (entry.name.endsWith('.guidance') || entry.name.endsWith('.jinja')) {
+                    files.push(fullPath);
+                }
+            }
+            return files;
+        };
+        const localFiles = await walkDir(projectsDir);
+        for (const localFile of localFiles) {
+            const relativePath = path.relative(process.cwd(), localFile);
+            const alreadyInDiffs = diffs.some(d => d.path === relativePath);
+            if (!alreadyInDiffs) {
+                const localContent = await fs.readFile(localFile, 'utf-8');
+                diffs.push({
+                    path: relativePath,
+                    type: 'added',
+                    localContent,
+                });
+            }
+        }
+    }
+    return diffs;
+}
+/**
+ * Get attribute differences
+ */
+async function getAttributeDiffs(client, customer, _verbose) {
+    const diffs = [];
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    // Customer attributes
+    const localAttrPath = path.join(customerDir, 'attributes.yaml');
+    if (await fs.pathExists(localAttrPath)) {
+        try {
+            const remoteAttrsResponse = await getCustomerAttributes(client, true);
+            const localContent = await fs.readFile(localAttrPath, 'utf-8');
+            // Transform remote to YAML format for comparison
+            const remoteYaml = yaml.dump(remoteAttrsResponse.attributes.map(attr => ({
+                idn: attr.idn,
+                title: attr.title,
+                value: attr.value,
+                value_type: attr.value_type,
+                is_hidden: attr.is_hidden,
+            })), { lineWidth: -1 });
+            const localParsed = yaml.load(localContent);
+            const localYaml = yaml.dump(localParsed, { lineWidth: -1 });
+            if (localYaml !== remoteYaml) {
+                diffs.push({
+                    path: path.relative(process.cwd(), localAttrPath),
+                    type: 'modified',
+                    localContent: localYaml,
+                    remoteContent: remoteYaml,
+                });
+            }
+        }
+        catch {
+            // Error fetching remote - skip
+        }
+    }
+    return diffs;
+}
+/**
+ * Main diff command handler
+ */
+export async function handleDiffCommand(customerConfig, args, verbose) {
+    const { selectedCustomer } = selectSingleCustomer(customerConfig, args.customer);
+    if (!selectedCustomer) {
+        console.error('❌ Please specify a customer with --customer <idn> or set a default');
+        process.exit(1);
+    }
+    // Parse options
+    const onlyResources = parseResourceList(args.only);
+    const detailed = Boolean(args.detailed || args.d);
+    // Determine resources to diff
+    let resourcesToDiff;
+    if (onlyResources.length > 0) {
+        resourcesToDiff = onlyResources.filter(r => ALL_RESOURCE_TYPES.includes(r));
+    }
+    else {
+        resourcesToDiff = ['projects', 'attributes']; // Default to main resources
+    }
+    console.log(`🔍 Comparing local vs remote for: ${resourcesToDiff.join(', ')}`);
+    console.log(`📁 Customer: ${selectedCustomer.idn}`);
+    console.log('');
+    const accessToken = await getValidAccessToken(selectedCustomer);
+    const client = await makeClient(verbose, accessToken);
+    const allDiffs = [];
+    // Get diffs for each resource type
+    for (const resource of resourcesToDiff) {
+        switch (resource) {
+            case 'projects':
+                console.log(`📦 Checking projects...`);
+                const projectDiffs = await getProjectDiffs(client, selectedCustomer, verbose);
+                allDiffs.push(...projectDiffs);
+                break;
+            case 'attributes':
+                console.log(`📋 Checking attributes...`);
+                const attrDiffs = await getAttributeDiffs(client, selectedCustomer, verbose);
+                allDiffs.push(...attrDiffs);
+                break;
+            default:
+                console.log(`⏭️  Skipping ${resource} (diff not implemented yet)`);
+        }
+    }
+    // Display results
+    console.log('');
+    if (allDiffs.length === 0) {
+        console.log('✅ No differences found. Local and remote are in sync.');
+        return;
+    }
+    console.log(`📊 Found ${allDiffs.length} difference(s):`);
+    console.log('');
+    // Group by type
+    const added = allDiffs.filter(d => d.type === 'added');
+    const modified = allDiffs.filter(d => d.type === 'modified');
+    const deleted = allDiffs.filter(d => d.type === 'deleted');
+    if (added.length > 0) {
+        console.log(`${colors.green}➕ Added locally (${added.length}):${colors.reset}`);
+        for (const diff of added) {
+            console.log(`   ${diff.path}`);
+        }
+        console.log('');
+    }
+    if (modified.length > 0) {
+        console.log(`${colors.yellow}📝 Modified (${modified.length}):${colors.reset}`);
+        for (const diff of modified) {
+            console.log(`   ${diff.path}`);
+            if (detailed && diff.localContent && diff.remoteContent) {
+                const diffOutput = generateUnifiedDiff(diff.localContent, diff.remoteContent, diff.path);
+                diffOutput.forEach(line => console.log(`      ${line}`));
+                console.log('');
+            }
+        }
+        console.log('');
+    }
+    if (deleted.length > 0) {
+        console.log(`${colors.red}➖ Deleted locally (${deleted.length}):${colors.reset}`);
+        for (const diff of deleted) {
+            console.log(`   ${diff.path}`);
+        }
+        console.log('');
+    }
+    // Summary
+    console.log(`${colors.cyan}Summary:${colors.reset}`);
+    console.log(`   Added: ${added.length}`);
+    console.log(`   Modified: ${modified.length}`);
+    console.log(`   Deleted: ${deleted.length}`);
+    console.log('');
+    console.log(`💡 Run ${colors.cyan}newo push${colors.reset} to upload local changes to remote.`);
+    console.log(`💡 Run ${colors.cyan}newo pull${colors.reset} to download remote changes to local.`);
+}
+//# sourceMappingURL=diff.js.map

package/dist/cli/commands/help.js

@@ -9,10 +9,13 @@ Core Commands:
   newo pull [--customer <idn>]                  # download projects + attributes -> ./newo_customers/<idn>/
   newo push [--customer <idn>] [--no-publish]    # upload modified *.guidance/*.jinja + attributes back to NEWO, publish flows by default
   newo status [--customer <idn>]                # show modified files that would be pushed
+  newo watch [--customer <idn>]                 # watch for file changes and auto-push (NEW)
+  newo diff [--customer <idn>]                  # show differences between local and remote (NEW)
+  newo logs [--customer <idn>]                  # fetch and display analytics logs from platform (NEW)
   newo conversations [--customer <idn>] [--all] # download user conversations -> ./newo_customers/<idn>/conversations.yaml
-  newo sandbox "<message>" [--customer <idn>]   # test agent in sandbox - single message mode (NEW v3.1.0)
+  newo sandbox "<message>" [--customer <idn>]   # test agent in sandbox - single message mode
   newo sandbox --actor <id> "message"           # continue existing sandbox conversation with chat ID
-  newo pull-attributes [--customer <idn>]       # download customer + project attributes -> ./newo_customers/<idn>/attributes.yaml + projects/{project}/attributes.yaml
+  newo pull-attributes [--customer <idn>]       # download customer + project attributes
   newo list-customers                           # list available customers and their configuration
   newo meta [--customer <idn>]                  # get project metadata (debug command)
   newo import-akb <file> <persona_id> [--customer <idn>]  # import AKB articles from structured text file
@@ -51,7 +54,20 @@ Enterprise Features:
   newo pull-akb [--customer <idn>]                          # download AKB articles for all personas with agents → ./newo_customers/<idn>/akb/
   newo push-akb [--customer <idn>]                          # upload AKB articles from local YAML files to platform
 
-Account Migration (NEW):
+Analytics & Monitoring (NEW):
+  newo logs [--customer <idn>]                               # fetch last 1 hour of analytics logs
+  newo logs --hours <n>                                      # fetch logs from last N hours
+  newo logs --from <datetime> --to <datetime>                # fetch logs in datetime range (ISO format)
+  newo logs --level <levels>                                 # filter by level: info, warning, error (comma-separated)
+  newo logs --type <types>                                   # filter by type: system, operation, call (comma-separated)
+  newo logs --flow <idn> --skill <idn>                       # filter by flow and/or skill
+  newo logs --message <text>                                 # search in log messages
+  newo logs --follow, -f                                     # tail mode - continuously poll for new logs
+  newo logs --json                                           # output logs as JSON array
+  newo logs --raw                                            # output each log as single JSON line (for piping)
+
+Account & Customer Management:
+  newo create-customer <org_name> --email <email> [--tenant <t>] [--phone <p>] [--project <idn>] [--status <temporal|permanent>]  # create new NEWO customer
   newo migrate-account --source <idn> --dest <idn> [--yes]  # migrate complete account from source to destination
   newo verify --source <idn> --dest <idn>                    # verify migration by comparing entity counts
   newo create-webhooks [--customer <idn>]                    # create webhooks from YAML files
@@ -66,6 +82,20 @@ Flags:
   --confirm                    # confirm destructive operations without prompting
   --no-publish                 # skip automatic flow publishing during push operations
 
+Selective Sync Flags (NEW):
+  --only <resources>           # sync only specified resources (comma-separated)
+  --exclude <resources>        # exclude specified resources from sync
+  --all                        # explicitly sync all resources
+  --debounce <ms>              # debounce delay for watch mode (default: 1000ms)
+  --detailed, -d               # show detailed content diff (for diff command)
+
+  Resources: projects, attributes, integrations, akb, conversations (read-only)
+  Examples:
+    newo pull --only projects,attributes      # pull only projects and attributes
+    newo push --exclude integrations          # push all except integrations
+    newo watch --only projects --debounce 2000  # watch projects with 2s delay
+    newo diff --only projects --detailed      # show project diffs with content
+
 Environment Variables:
   NEWO_BASE_URL                                 # NEWO API base URL (default: https://app.newo.ai)
 
@@ -100,6 +130,21 @@ Usage Examples:
   newo status                                  # Check for local modifications
   newo push                                    # Upload changes back to NEWO
 
+  # Watch mode (auto-push on changes):
+  newo watch                                   # Watch all files and auto-push changes
+  newo watch --only projects                   # Watch only project files
+  newo watch --debounce 2000                   # 2-second debounce delay
+
+  # Diff (compare local vs remote):
+  newo diff                                    # Show all differences
+  newo diff --only projects                    # Show only project differences
+  newo diff --detailed                         # Show content-level diffs
+
+  # Selective sync:
+  newo pull --only projects                    # Pull only projects
+  newo push --exclude integrations             # Push all except integrations
+  newo pull --all                              # Explicit all resources
+
   # Multi-customer operations:
   newo pull --customer acme                    # Pull projects for Acme only
   newo push --customer globex                  # Push changes for Globex only
@@ -139,6 +184,21 @@ Usage Examples:
   newo sandbox "Test query" --verbose                            # With debug info
   newo sandbox "Test query" --quiet                              # For automation/scripts
 
+  # Analytics logs (NEW v3.5.0):
+  newo logs                                                      # Last 1 hour of logs
+  newo logs --hours 24                                           # Last 24 hours
+  newo logs --level warning,error                                # Only warnings and errors
+  newo logs --type call --skill CreateActor                      # Skill calls for specific skill
+  newo logs --flow CACreatorFlow --follow                        # Tail logs for specific flow
+  newo logs --from "2026-01-11T00:00:00Z" --to "2026-01-12T00:00:00Z"  # Date range
+  newo logs --json --per 100                                     # Get 100 logs as JSON
+  newo logs --message "error" --level error                      # Search errors with message
+
+  # Customer creation (NEW v3.5.0):
+  newo create-customer "Acme Corp" --email admin@acme.com --tenant acme   # Create basic customer
+  newo create-customer "Test Co" --email test@test.com --status temporal  # Temporal (trial) customer
+  newo create-customer "Partner" --email p@p.com --project nac_integration --auto-update  # With project template
+
 File Structure:
   newo_customers/
   ├── <customer-idn>/

package/dist/cli/commands/logs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Logs command - Fetch and display analytics logs from NEWO platform
+ *
+ * Usage:
+ *   newo logs                              # Last 1 hour of logs
+ *   newo logs --hours 24                   # Last 24 hours
+ *   newo logs --from "2026-01-11T00:00:00Z" --to "2026-01-12T00:00:00Z"
+ *   newo logs --level warning              # Only warnings
+ *   newo logs --type call                  # Only skill calls
+ *   newo logs --flow CACreatorFlow         # Filter by flow
+ *   newo logs --skill CreateActor          # Filter by skill
+ *   newo logs --follow                     # Tail mode (poll for new logs)
+ *   newo logs --json                       # Output as JSON
+ */
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleLogsCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+export declare function printLogsHelp(): void;
+//# sourceMappingURL=logs.d.ts.map