newo 3.1.0 → 3.2.0

package/dist/sync/akb.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AKB (Knowledge Base) synchronization module
+ * Handles pull/push of AKB articles for personas with agents
+ */
+import type { AxiosInstance } from 'axios';
+/**
+ * Pull AKB articles for all personas linked to agents
+ */
+export declare function pullAkb(client: AxiosInstance, customerDir: string, verbose?: boolean): Promise<void>;
+/**
+ * Push AKB articles from local files to NEWO platform
+ */
+export declare function pushAkb(client: AxiosInstance, customerDir: string, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=akb.d.ts.map

package/dist/sync/akb.js

@@ -0,0 +1,175 @@
+/**
+ * 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 { searchPersonas, getAkbTopics, importAkbArticle } from '../api.js';
+/**
+ * Pull AKB articles for all personas linked to agents
+ */
+export async function pullAkb(client, customerDir, verbose = false) {
+    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 = [];
+    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 = [];
+        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) {
+                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 = 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, customerDir, verbose = false) {
+    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 = [];
+    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();
+    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'));
+        if (!Array.isArray(topics)) {
+            if (verbose)
+                console.log(`     ⚠ Invalid YAML format, skipping...`);
+            continue;
+        }
+        // Import each article
+        for (const topic of topics) {
+            try {
+                const articleData = {
+                    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) {
+                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`);
+    }
+}
+//# sourceMappingURL=akb.js.map

package/dist/sync/attributes.d.ts

@@ -4,4 +4,23 @@ import type { CustomerConfig } from '../types.js';
  * Save customer attributes to YAML format and return content for hashing
  */
 export declare function saveCustomerAttributes(client: AxiosInstance, customer: CustomerConfig, verbose?: boolean): Promise<string>;
+/**
+ * Save project attributes to YAML format in project directory
+ */
+export declare function saveProjectAttributes(client: AxiosInstance, customer: CustomerConfig, projectId: string, projectIdn: string, verbose?: boolean): Promise<void>;
+/**
+ * Pull all project attributes for a customer
+ */
+export declare function pullAllProjectAttributes(client: AxiosInstance, customer: CustomerConfig, verbose?: boolean): Promise<void>;
+/**
+ * Push modified project attributes for a specific project
+ */
+export declare function pushProjectAttributes(client: AxiosInstance, customer: CustomerConfig, projectId: string, projectIdn: string, verbose?: boolean): Promise<number>;
+/**
+ * Push all modified project attributes for all projects
+ */
+export declare function pushAllProjectAttributes(client: AxiosInstance, customer: CustomerConfig, projectsMap: Record<string, {
+    projectId: string;
+    projectIdn: string;
+}>, verbose?: boolean): Promise<number>;
 //# sourceMappingURL=attributes.d.ts.map

package/dist/sync/attributes.js

@@ -1,8 +1,10 @@
 /**
- * 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';
 /**
  * Save customer attributes to YAML format and return content for hashing
@@ -87,4 +89,221 @@ export async function saveCustomerAttributes(client, customer, verbose = false)
         throw error;
     }
 }
+/**
+ * Save project attributes to YAML format in project directory
+ */
+export async function saveProjectAttributes(client, customer, projectId, projectIdn, verbose = false) {
+    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 = {};
+        // 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) {
+        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, customer, verbose = false) {
+    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, customer, projectId, projectIdn, verbose = false) {
+    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);
+    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'));
+    // 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();
+    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) {
+                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, customer, projectsMap, verbose = false) {
+    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;
+}
 //# sourceMappingURL=attributes.js.map

package/dist/sync/integrations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Integration and connector synchronization module
+ * Handles pull/push of integrations and connectors to/from NEWO platform
+ */
+import type { AxiosInstance } from 'axios';
+import type { IntegrationMetadata, ConnectorMetadata } from '../types.js';
+/**
+ * Pull all integrations and connectors from NEWO platform
+ */
+export declare function pullIntegrations(client: AxiosInstance, customerDir: string, verbose?: boolean): Promise<void>;
+/**
+ * Push integration changes from local files to NEWO platform
+ */
+export declare function pushIntegrations(client: AxiosInstance, customerDir: string, verbose?: boolean): Promise<void>;
+/**
+ * List all local integrations from file system
+ */
+export declare function listLocalIntegrations(customerDir: string): Promise<IntegrationMetadata[]>;
+/**
+ * Get connector details from local file
+ */
+export declare function getLocalConnector(customerDir: string, integrationIdn: string, connectorIdn: string): Promise<ConnectorMetadata | null>;
+//# sourceMappingURL=integrations.d.ts.map