newo 3.1.0 → 3.2.0

package/src/cli.ts

@@ -29,6 +29,12 @@ import { handleCreateParameterCommand } from './cli/commands/create-parameter.js
 import { handleCreatePersonaCommand } from './cli/commands/create-persona.js';
 import { handleCreateAttributeCommand } from './cli/commands/create-attribute.js';
 import { handleSandboxCommand } from './cli/commands/sandbox.js';
+import { handlePullIntegrationsCommand } from './cli/commands/pull-integrations.js';
+import { handlePushIntegrationsCommand } from './cli/commands/push-integrations.js';
+import { handleListActionsCommand } from './cli/commands/list-actions.js';
+import { handleProfileCommand } from './cli/commands/profile.js';
+import { handlePullAkbCommand } from './cli/commands/pull-akb.js';
+import { handlePushAkbCommand } from './cli/commands/push-akb.js';
 import type { CliArgs, NewoApiError } from './types.js';
 
 dotenv.config();
@@ -158,6 +164,30 @@ async function main(): Promise<void> {
         await handleCreateAttributeCommand(customerConfig, args, verbose);
         break;
 
+      case 'pull-integrations':
+        await handlePullIntegrationsCommand(customerConfig, args, verbose);
+        break;
+
+      case 'push-integrations':
+        await handlePushIntegrationsCommand(customerConfig, args, verbose);
+        break;
+
+      case 'list-actions':
+        await handleListActionsCommand(customerConfig, args, verbose);
+        break;
+
+      case 'profile':
+        await handleProfileCommand(customerConfig, args, verbose);
+        break;
+
+      case 'pull-akb':
+        await handlePullAkbCommand(customerConfig, args, verbose);
+        break;
+
+      case 'push-akb':
+        await handlePushAkbCommand(customerConfig, args, verbose);
+        break;
+
       default:
         console.error('Unknown command:', cmd);
         console.error('Run "newo --help" for usage information');

package/src/sync/akb.ts

@@ -0,0 +1,205 @@
+/**
+ * AKB (Knowledge Base) synchronization module
+ * Handles pull/push of AKB articles for personas with agents
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import type { AxiosInstance } from 'axios';
+import { searchPersonas, getAkbTopics, importAkbArticle } from '../api.js';
+import type {
+  Persona,
+  AkbTopicItem,
+  AkbYamlTopic,
+  AkbImportArticle
+} from '../types.js';
+
+/**
+ * Pull AKB articles for all personas linked to agents
+ */
+export async function pullAkb(
+  client: AxiosInstance,
+  customerDir: string,
+  verbose: boolean = false
+): Promise<void> {
+  if (verbose) console.log('\n📚 Pulling AKB (Knowledge Base) from NEWO platform...\n');
+
+  // Create AKB directory
+  const akbDir = path.join(customerDir, 'akb');
+  await fs.ensureDir(akbDir);
+
+  // Fetch personas linked to agents
+  let allPersonas: Persona[] = [];
+  let page = 1;
+  const perPage = 30;
+
+  while (true) {
+    const response = await searchPersonas(client, true, page, perPage);
+    allPersonas = allPersonas.concat(response.items);
+
+    if (verbose) console.log(`✓ Fetched ${response.items.length} personas (page ${page}/${Math.ceil(response.metadata.total / perPage)})`);
+
+    if (response.items.length < perPage || allPersonas.length >= response.metadata.total) {
+      break;
+    }
+    page++;
+  }
+
+  if (verbose) console.log(`\n✓ Found ${allPersonas.length} personas linked to agents`);
+
+  let totalArticles = 0;
+
+  // Fetch AKB articles for each persona
+  for (const persona of allPersonas) {
+    if (verbose) console.log(`\n  📖 Processing persona: ${persona.name} (${persona.agent.idn})`);
+
+    // Fetch all AKB topics for this persona
+    let allTopicItems: AkbTopicItem[] = [];
+    let topicPage = 1;
+    const topicsPerPage = 100;
+
+    while (true) {
+      try {
+        const topicsResponse = await getAkbTopics(client, persona.id, topicPage, topicsPerPage);
+        allTopicItems = allTopicItems.concat(topicsResponse.items);
+
+        if (verbose) console.log(`     ✓ Fetched ${topicsResponse.items.length} topics (page ${topicPage})`);
+
+        if (topicsResponse.items.length < topicsPerPage || allTopicItems.length >= topicsResponse.metadata.total) {
+          break;
+        }
+        topicPage++;
+      } catch (error: any) {
+        if (verbose) console.log(`     ⚠ Could not fetch topics: ${error.message}`);
+        break;
+      }
+    }
+
+    if (allTopicItems.length > 0) {
+      // Convert to YAML format (extract topic from each item)
+      const yamlTopics: AkbYamlTopic[] = allTopicItems.map(item => ({
+        topic_name: item.topic.topic_name,
+        topic_facts: [...item.topic.topic_facts],
+        confidence: item.topic.confidence,
+        source: item.topic.source,
+        created_at: item.topic.created_at,
+        updated_at: item.topic.updated_at,
+        labels: [...item.topic.labels],
+        topic_summary: item.topic.topic_summary
+      }));
+
+      // Save to persona-specific YAML file using agent IDN
+      const agentIdn = persona.agent.idn;
+      const akbFile = path.join(akbDir, `${agentIdn}.yaml`);
+      await fs.writeFile(akbFile, yaml.dump(yamlTopics, { lineWidth: -1 }));
+
+      if (verbose) console.log(`     ✓ Saved ${allTopicItems.length} articles → ${agentIdn}.yaml`);
+      totalArticles += allTopicItems.length;
+    } else {
+      if (verbose) console.log(`     ℹ No AKB articles found for this persona`);
+    }
+  }
+
+  if (verbose) {
+    console.log(`\n✅ Saved AKB articles for ${allPersonas.length} personas`);
+    console.log(`   Total articles: ${totalArticles}\n`);
+  }
+}
+
+/**
+ * Push AKB articles from local files to NEWO platform
+ */
+export async function pushAkb(
+  client: AxiosInstance,
+  customerDir: string,
+  verbose: boolean = false
+): Promise<void> {
+  if (verbose) console.log('\n📤 Pushing AKB articles to NEWO platform...\n');
+
+  const akbDir = path.join(customerDir, 'akb');
+
+  // Check if AKB directory exists
+  if (!await fs.pathExists(akbDir)) {
+    if (verbose) console.log('⚠ No akb directory found. Run pull-akb first.');
+    return;
+  }
+
+  // Get personas linked to agents for ID mapping
+  let allPersonas: Persona[] = [];
+  let page = 1;
+  const perPage = 30;
+
+  while (true) {
+    const response = await searchPersonas(client, true, page, perPage);
+    allPersonas = allPersonas.concat(response.items);
+    if (response.items.length < perPage || allPersonas.length >= response.metadata.total) {
+      break;
+    }
+    page++;
+  }
+
+  // Create persona mapping (agent.idn -> persona.id)
+  const personaMap = new Map<string, string>();
+  allPersonas.forEach(persona => {
+    personaMap.set(persona.agent.idn, persona.id);
+    personaMap.set(persona.name, persona.id); // Also map by name as fallback
+  });
+
+  // Read AKB files
+  const akbFiles = await fs.readdir(akbDir);
+  let totalImported = 0;
+  let totalFailed = 0;
+
+  for (const file of akbFiles) {
+    if (!file.endsWith('.yaml')) continue;
+
+    const fileBase = file.replace('.yaml', '');
+    const personaId = personaMap.get(fileBase);
+
+    if (!personaId) {
+      if (verbose) console.log(`⚠ Persona not found for file: ${file}, skipping...`);
+      continue;
+    }
+
+    if (verbose) console.log(`\n  📖 Processing: ${file}`);
+
+    // Read YAML file
+    const akbFile = path.join(akbDir, file);
+    const topics = yaml.load(await fs.readFile(akbFile, 'utf-8')) as AkbYamlTopic[];
+
+    if (!Array.isArray(topics)) {
+      if (verbose) console.log(`     ⚠ Invalid YAML format, skipping...`);
+      continue;
+    }
+
+    // Import each article
+    for (const topic of topics) {
+      try {
+        const articleData: AkbImportArticle = {
+          topic_name: topic.topic_name,
+          topic_summary: topic.topic_summary,
+          topic_facts: topic.topic_facts,
+          confidence: topic.confidence,
+          source: topic.source,
+          labels: topic.labels,
+          persona_id: personaId
+        };
+
+        await importAkbArticle(client, articleData);
+        totalImported++;
+
+        if (verbose) console.log(`     ✓ Imported: ${topic.topic_name}`);
+      } catch (error: any) {
+        totalFailed++;
+        if (verbose) console.error(`     ❌ Failed to import ${topic.topic_name}: ${error.message}`);
+      }
+    }
+  }
+
+  if (verbose) {
+    console.log(`\n✅ Push completed:`);
+    console.log(`   Imported: ${totalImported}`);
+    console.log(`   Failed: ${totalFailed}\n`);
+  }
+}

package/src/sync/attributes.ts

@@ -1,13 +1,15 @@
 /**
- * Customer attributes synchronization module
+ * Customer and project attributes synchronization module
  */
-import { getCustomerAttributes } from '../api.js';
+import { getCustomerAttributes, getProjectAttributes, listProjects, updateProjectAttribute } from '../api.js';
 import {
   writeFileSafe,
   customerAttributesPath,
   customerAttributesMapPath,
   customerAttributesBackupPath
 } from '../fsutil.js';
+import path from 'path';
+import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import type { AxiosInstance } from 'axios';
 import type { CustomerConfig } from '../types.js';
@@ -107,4 +109,269 @@ export async function saveCustomerAttributes(
     console.error(`❌ Failed to save customer attributes for ${customer.idn}:`, error);
     throw error;
   }
+}
+
+/**
+ * Save project attributes to YAML format in project directory
+ */
+export async function saveProjectAttributes(
+  client: AxiosInstance,
+  customer: CustomerConfig,
+  projectId: string,
+  projectIdn: string,
+  verbose: boolean = false
+): Promise<void> {
+  if (verbose) console.log(`   🔍 Fetching project attributes for ${projectIdn}...`);
+
+  try {
+    const response = await getProjectAttributes(client, projectId, true); // Include hidden attributes
+
+    // API returns { groups: [...], attributes: [...] }
+    const attributes = response.attributes || response;
+    if (verbose) console.log(`   📦 Found ${Array.isArray(attributes) ? attributes.length : 0} project attributes`);
+
+    if (!Array.isArray(attributes) || attributes.length === 0) {
+      if (verbose) console.log(`   ℹ No project attributes found for ${projectIdn}`);
+      return;
+    }
+
+    // Create ID mapping for push operations
+    const idMapping: Record<string, string> = {};
+
+    // Transform attributes to match format (no ID fields)
+    const cleanAttributes = attributes.map(attr => {
+      // Store ID mapping
+      if (attr.id) {
+        idMapping[attr.idn] = attr.id;
+      }
+
+      // Special handling for complex JSON string values
+      let processedValue = attr.value;
+      if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+        try {
+          const parsed = JSON.parse(attr.value);
+          processedValue = JSON.stringify(parsed, null, 0);
+        } catch (e) {
+          processedValue = attr.value;
+        }
+      }
+
+      return {
+        idn: attr.idn,
+        value: processedValue,
+        title: attr.title || "",
+        description: attr.description || "",
+        group: attr.group || "",
+        is_hidden: attr.is_hidden,
+        possible_values: attr.possible_values || [],
+        value_type: `__ENUM_PLACEHOLDER_${attr.value_type}__`
+      };
+    });
+
+    const attributesYaml = {
+      attributes: cleanAttributes
+    };
+
+    // Configure YAML output
+    let yamlContent = yaml.dump(attributesYaml, {
+      indent: 2,
+      quotingType: '"',
+      forceQuotes: false,
+      lineWidth: 80,
+      noRefs: true,
+      sortKeys: false,
+      flowLevel: -1
+    });
+
+    // Post-process to fix enum format
+    yamlContent = yamlContent.replace(/__ENUM_PLACEHOLDER_(\w+)__/g, '!enum "AttributeValueTypes.$1"');
+    yamlContent = yamlContent.replace(/\\"/g, '"');
+
+    // Save to project directory
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    const projectDir = path.join(customerDir, 'projects', projectIdn);
+    await fs.ensureDir(projectDir);
+
+    const attributesFile = path.join(projectDir, 'attributes.yaml');
+    const attributesMapFile = path.join(customerDir, '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+
+    await writeFileSafe(attributesFile, yamlContent);
+    await fs.ensureDir(path.dirname(attributesMapFile));
+    await writeFileSafe(attributesMapFile, JSON.stringify(idMapping, null, 2));
+
+    if (verbose) {
+      console.log(`   ✓ Saved project attributes to projects/${projectIdn}/attributes.yaml`);
+      console.log(`   ✓ Saved attribute ID mapping`);
+    }
+  } catch (error: any) {
+    if (verbose) console.error(`   ❌ Failed to fetch project attributes for ${projectIdn}:`, error.message);
+  }
+}
+
+/**
+ * Pull all project attributes for a customer
+ */
+export async function pullAllProjectAttributes(
+  client: AxiosInstance,
+  customer: CustomerConfig,
+  verbose: boolean = false
+): Promise<void> {
+  if (verbose) console.log(`\n📋 Fetching project attributes...`);
+
+  try {
+    // Get all projects for this customer
+    const projects = await listProjects(client);
+    if (verbose) console.log(`✓ Found ${projects.length} projects\n`);
+
+    for (const project of projects) {
+      await saveProjectAttributes(client, customer, project.id, project.idn, verbose);
+    }
+
+    if (verbose) console.log(`\n✅ Completed project attributes sync for ${projects.length} projects\n`);
+  } catch (error) {
+    console.error(`❌ Failed to pull project attributes:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Push modified project attributes for a specific project
+ */
+export async function pushProjectAttributes(
+  client: AxiosInstance,
+  customer: CustomerConfig,
+  projectId: string,
+  projectIdn: string,
+  verbose: boolean = false
+): Promise<number> {
+  const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+  const attributesFile = path.join(customerDir, 'projects', projectIdn, 'attributes.yaml');
+  const attributesMapFile = path.join(customerDir, '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+
+  // Check if attributes file exists
+  if (!await fs.pathExists(attributesFile)) {
+    if (verbose) console.log(`   ℹ No project attributes file for ${projectIdn}`);
+    return 0;
+  }
+
+  // Load local attributes
+  // Read as text and replace the custom !enum tags before parsing
+  let attributesContent = await fs.readFile(attributesFile, 'utf-8');
+  // Replace custom enum tags with the actual value
+  attributesContent = attributesContent.replace(/!enum "AttributeValueTypes\.(\w+)"/g, '$1');
+
+  const localData = yaml.load(attributesContent) as { attributes: any[] };
+  const localAttributes = localData.attributes || [];
+
+  // Load ID mapping
+  if (!await fs.pathExists(attributesMapFile)) {
+    if (verbose) console.log(`   ⚠ No ID mapping found for project ${projectIdn}, skipping push`);
+    return 0;
+  }
+
+  const idMapping = JSON.parse(await fs.readFile(attributesMapFile, 'utf-8')) as Record<string, string>;
+
+  // Fetch current remote attributes for comparison
+  const remoteResponse = await getProjectAttributes(client, projectId, true);
+  const remoteAttributes = remoteResponse.attributes || [];
+
+  // Create map of remote attributes by IDN
+  const remoteMap = new Map<string, any>();
+  remoteAttributes.forEach(attr => remoteMap.set(attr.idn, attr));
+
+  let updatedCount = 0;
+
+  // Check each local attribute for changes
+  for (const localAttr of localAttributes) {
+    const attributeId = idMapping[localAttr.idn];
+    if (!attributeId) {
+      if (verbose) console.log(`   ⚠ No ID mapping for attribute ${localAttr.idn}, skipping`);
+      continue;
+    }
+
+    const remoteAttr = remoteMap.get(localAttr.idn);
+    if (!remoteAttr) {
+      if (verbose) console.log(`   ⚠ Attribute ${localAttr.idn} not found remotely, skipping`);
+      continue;
+    }
+
+    // Value type is already parsed (we removed !enum tags above)
+    const valueType = localAttr.value_type;
+
+    // Check if value changed
+    const localValue = String(localAttr.value || '');
+    const remoteValue = String(remoteAttr.value || '');
+
+    if (localValue !== remoteValue) {
+      if (verbose) console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);
+
+      try {
+        const attributeToUpdate = {
+          id: attributeId,
+          idn: localAttr.idn,
+          value: localAttr.value,
+          title: localAttr.title,
+          description: localAttr.description,
+          group: localAttr.group,
+          is_hidden: localAttr.is_hidden,
+          possible_values: localAttr.possible_values,
+          value_type: valueType
+        };
+
+        await updateProjectAttribute(client, projectId, attributeToUpdate);
+        if (verbose) console.log(`   ✅ Updated: ${localAttr.idn} (${localAttr.title})`);
+        updatedCount++;
+      } catch (error: any) {
+        const errorDetail = error.response?.data || error.message;
+        console.error(`   ❌ Failed to update ${localAttr.idn}: ${JSON.stringify(errorDetail)}`);
+        if (verbose) {
+          console.error(`      API response:`, error.response?.status, error.response?.statusText);
+          console.error(`      Endpoint tried: PUT /api/v1/project/attributes/${attributeId}`);
+        }
+      }
+    } else if (verbose) {
+      console.log(`   ✓ No changes: ${localAttr.idn}`);
+    }
+  }
+
+  return updatedCount;
+}
+
+/**
+ * Push all modified project attributes for all projects
+ */
+export async function pushAllProjectAttributes(
+  client: AxiosInstance,
+  customer: CustomerConfig,
+  projectsMap: Record<string, { projectId: string; projectIdn: string }>,
+  verbose: boolean = false
+): Promise<number> {
+  if (verbose) console.log(`\n📋 Checking project attributes for changes...`);
+
+  let totalUpdated = 0;
+
+  for (const [projectIdn, projectInfo] of Object.entries(projectsMap)) {
+    if (!projectIdn) continue; // Skip empty project idn (legacy format)
+
+    if (verbose) console.log(`\n  📁 Project: ${projectIdn}`);
+
+    const updated = await pushProjectAttributes(
+      client,
+      customer,
+      projectInfo.projectId,
+      projectInfo.projectIdn || projectIdn,
+      verbose
+    );
+
+    totalUpdated += updated;
+  }
+
+  // Always show summary if changes were made
+  if (totalUpdated > 0) {
+    console.log(`\n✅ Updated ${totalUpdated} project attribute(s)`);
+  } else {
+    if (verbose) console.log(`\n✓ No project attribute changes to push`);
+  }
+
+  return totalUpdated;
 }