newo 3.4.0 → 3.4.2

package/src/cli/commands/diff.ts

@@ -0,0 +1,360 @@
+/**
+ * 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 type { MultiCustomerConfig, CliArgs, CustomerConfig } from '../../types.js';
+import type { AxiosInstance } from 'axios';
+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: string | undefined): string[] {
+  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',
+};
+
+/**
+ * Diff entry for display
+ */
+interface DiffEntry {
+  path: string;
+  type: 'added' | 'modified' | 'deleted' | 'unchanged';
+  localContent?: string;
+  remoteContent?: string;
+}
+
+/**
+ * Generate unified diff output
+ */
+function generateUnifiedDiff(local: string, remote: string, filePath: string): string[] {
+  const localLines = local.split('\n');
+  const remoteLines = remote.split('\n');
+  const output: string[] = [];
+
+  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: string[] = [];
+
+  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: AxiosInstance,
+  customer: CustomerConfig,
+  _verbose: boolean
+): Promise<DiffEntry[]> {
+  const diffs: DiffEntry[] = [];
+  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: string): Promise<string[]> => {
+      const files: string[] = [];
+      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: AxiosInstance,
+  customer: CustomerConfig,
+  _verbose: boolean
+): Promise<DiffEntry[]> {
+  const diffs: DiffEntry[] = [];
+  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: MultiCustomerConfig,
+  args: CliArgs,
+  verbose: boolean
+): Promise<void> {
+  const { selectedCustomer } = selectSingleCustomer(
+    customerConfig,
+    args.customer as string | undefined
+  );
+
+  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 as string | undefined);
+  const detailed = Boolean(args.detailed || args.d);
+
+  // Determine resources to diff
+  let resourcesToDiff: string[];
+  if (onlyResources.length > 0) {
+    resourcesToDiff = onlyResources.filter(r => ALL_RESOURCE_TYPES.includes(r as typeof ALL_RESOURCE_TYPES[number]));
+  } 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: DiffEntry[] = [];
+
+  // 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.`);
+}

package/src/cli/commands/help.ts

@@ -10,10 +10,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
@@ -52,7 +55,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
@@ -67,6 +83,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)
 
@@ -101,6 +131,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
@@ -140,6 +185,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>/