newo 3.4.2 → 3.6.0

package/dist/cli-new/di/tokens.d.ts

@@ -41,6 +41,7 @@ export declare const TOKENS: {
     readonly CUSTOMER_SELECTOR: symbol;
     readonly CUSTOMER_CONFIG: symbol;
     readonly ENVIRONMENT: symbol;
+    readonly FORMAT_VERSION: symbol;
 };
 /**
  * Type for the tokens object

package/dist/cli-new/di/tokens.js

@@ -53,6 +53,7 @@ export const TOKENS = {
     // Configuration
     CUSTOMER_CONFIG: Symbol('CustomerConfig'),
     ENVIRONMENT: Symbol('Environment'),
+    FORMAT_VERSION: Symbol('FormatVersion'),
 };
 /**
  * Resource types for selective sync

package/dist/cli.js

@@ -46,6 +46,7 @@ import { handleAddProjectCommand } from './cli/commands/add-project.js';
 import { handleWatchCommand } from './cli/commands/watch.js';
 import { handleDiffCommand } from './cli/commands/diff.js';
 import { handleLogsCommand } from './cli/commands/logs.js';
+import { handleExportCommand } from './cli/commands/export.js';
 dotenv.config();
 async function main() {
     try {
@@ -100,6 +101,9 @@ async function main() {
             case 'logs':
                 await handleLogsCommand(customerConfig, args, verbose);
                 break;
+            case 'export':
+                await handleExportCommand(customerConfig, args, verbose);
+                break;
             case 'conversations':
                 await handleConversationsCommand(customerConfig, args, verbose);
                 break;

package/dist/domain/strategies/sync/ProjectSyncStrategy.d.ts

@@ -79,6 +79,11 @@ export declare class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, L
      * Push a skill update
      */
     private pushSkillUpdate;
+    /**
+     * Push a library skill update
+     * Path: newo_customers/{customer}/projects/{project}/libraries/{lib}/{skill}/{skill}.jinja
+     */
+    private pushLibrarySkillUpdate;
     /**
      * Push a new entity
      */

package/dist/domain/strategies/sync/ProjectSyncStrategy.js

@@ -12,8 +12,8 @@
  */
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
-import { listProjects, listAgents, listFlowSkills, listFlowEvents, listFlowStates, updateSkill, publishFlow } from '../../../api.js';
-import { ensureState, writeFileSafe, mapPath, projectMetadataPath, agentMetadataPath, flowMetadataPath, skillMetadataPath, skillScriptPath, skillFolderPath, flowsYamlPath, customerProjectsDir, projectDir } from '../../../fsutil.js';
+import { listProjects, listAgents, listFlowSkills, listFlowEvents, listFlowStates, updateSkill, publishFlow, listLibraries, updateLibrarySkill, } from '../../../api.js';
+import { ensureState, writeFileSafe, mapPath, projectMetadataPath, agentMetadataPath, flowMetadataPath, skillMetadataPath, skillScriptPath, skillFolderPath, flowsYamlPath, customerProjectsDir, projectDir, libraryMetadataPath, librarySkillMetadataPath, librarySkillScriptPath, } from '../../../fsutil.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 import { generateFlowsYaml } from '../../../sync/metadata.js';
 import { findSkillScriptFiles, isContentDifferent, getExtensionForRunner, getSingleSkillFile, validateSkillFolder } from '../../../sync/skill-files.js';
@@ -129,6 +129,47 @@ export class ProjectSyncStrategy {
                     }
                 }
             }
+            // Pull libraries for this project
+            try {
+                const libraries = await listLibraries(client, project.id);
+                if (libraries.length > 0) {
+                    this.logger.verbose(`  Found ${libraries.length} libraries in project ${project.idn}`);
+                    projectData.libraries = {};
+                    for (const lib of libraries) {
+                        projectData.libraries[lib.idn] = {
+                            id: lib.id,
+                            skills: {}
+                        };
+                        // Save library metadata
+                        const libMetaPath = libraryMetadataPath(customer.idn, project.idn, lib.idn);
+                        const libMeta = { id: lib.id, idn: lib.idn };
+                        const libMetaYaml = yaml.dump(libMeta, { indent: 2, quotingType: '"', forceQuotes: false });
+                        await writeFileSafe(libMetaPath, libMetaYaml);
+                        hashes[libMetaPath] = sha256(libMetaYaml);
+                        for (const skill of lib.skills) {
+                            // Save skill metadata
+                            const skillMetaPath = librarySkillMetadataPath(customer.idn, project.idn, lib.idn, skill.idn);
+                            const skillMeta = {
+                                id: skill.id, idn: skill.idn, title: skill.title,
+                                runner_type: skill.runner_type, model: skill.model,
+                                parameters: [...skill.parameters], path: skill.path
+                            };
+                            const skillMetaYaml = yaml.dump(skillMeta, { indent: 2, quotingType: '"', forceQuotes: false });
+                            await writeFileSafe(skillMetaPath, skillMetaYaml);
+                            hashes[skillMetaPath] = sha256(skillMetaYaml);
+                            // Save skill script
+                            const scriptContent = skill.prompt_script || '';
+                            const scriptPath = librarySkillScriptPath(customer.idn, project.idn, lib.idn, skill.idn, skill.runner_type);
+                            await writeFileSafe(scriptPath, scriptContent);
+                            hashes[scriptPath] = sha256(scriptContent);
+                            projectData.libraries[lib.idn].skills[skill.idn] = skillMeta;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.verbose(`  Could not pull libraries for project ${project.idn}: ${error instanceof Error ? error.message : String(error)}`);
+            }
             existingMap.projects[project.idn] = projectData;
             projects.push(localProject);
         }
@@ -313,12 +354,17 @@ export class ProjectSyncStrategy {
         for (const change of changes) {
             try {
                 if (change.operation === 'modified') {
-                    // Update existing skill
-                    const updateResult = await this.pushSkillUpdate(client, customer, change, mapData, newHashes);
-                    result.updated += updateResult;
+                    const isLibrary = change.path.includes('/libraries/');
+                    if (isLibrary) {
+                        const updateResult = await this.pushLibrarySkillUpdate(client, change, mapData, newHashes);
+                        result.updated += updateResult;
+                    }
+                    else {
+                        const updateResult = await this.pushSkillUpdate(client, customer, change, mapData, newHashes);
+                        result.updated += updateResult;
+                    }
                 }
                 else if (change.operation === 'created') {
-                    // Create new entity
                     const createResult = await this.pushNewEntity(client, customer, change, mapData, newHashes);
                     result.created += createResult;
                 }
@@ -372,6 +418,29 @@ export class ProjectSyncStrategy {
         this.logger.info(`↑ Pushed: ${skillIdn}`);
         return 1;
     }
+    /**
+     * Push a library skill update
+     * Path: newo_customers/{customer}/projects/{project}/libraries/{lib}/{skill}/{skill}.jinja
+     */
+    async pushLibrarySkillUpdate(client, change, mapData, newHashes) {
+        const pathParts = change.path.split('/');
+        const skillIdn = pathParts[pathParts.length - 2] || '';
+        const libIdn = pathParts[pathParts.length - 3] || '';
+        const projectIdn = pathParts[pathParts.length - 5] || '';
+        const projectData = mapData.projects[projectIdn];
+        const libData = projectData?.libraries?.[libIdn];
+        const skillData = libData?.skills[skillIdn];
+        if (!skillData || !libData) {
+            throw new Error(`Library skill ${skillIdn} not found in project map`);
+        }
+        const content = await fs.readFile(change.path, 'utf8');
+        await updateLibrarySkill(client, libData.id, skillData.id, {
+            prompt_script: content,
+        });
+        newHashes[change.path] = sha256(content);
+        this.logger.info(`Pushed library skill: ${libIdn}/${skillIdn}`);
+        return 1;
+    }
     /**
      * Push a new entity
      */
@@ -415,7 +484,7 @@ export class ProjectSyncStrategy {
         }
         const hashes = await loadHashes(customer.idn);
         const mapData = await fs.readJson(mapFile);
-        // Scan for changed skill scripts
+        // Scan for changed flow skill scripts
         for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
             for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
                 for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
@@ -426,7 +495,7 @@ export class ProjectSyncStrategy {
                             const storedHash = hashes[skillFile.filePath];
                             if (storedHash !== currentHash) {
                                 changes.push({
-                                    item: {}, // Simplified for now
+                                    item: {},
                                     operation: 'modified',
                                     path: skillFile.filePath
                                 });
@@ -435,6 +504,26 @@ export class ProjectSyncStrategy {
                     }
                 }
             }
+            // Scan for changed library skill scripts
+            if (projectData.libraries) {
+                for (const [libIdn, libData] of Object.entries(projectData.libraries)) {
+                    for (const [skillIdn, skillMeta] of Object.entries(libData.skills)) {
+                        const scriptPath = librarySkillScriptPath(customer.idn, projectIdn, libIdn, skillIdn, skillMeta.runner_type);
+                        if (await fs.pathExists(scriptPath)) {
+                            const content = await fs.readFile(scriptPath, 'utf8');
+                            const currentHash = sha256(content);
+                            const storedHash = hashes[scriptPath];
+                            if (storedHash !== currentHash) {
+                                changes.push({
+                                    item: {},
+                                    operation: 'modified',
+                                    path: scriptPath
+                                });
+                            }
+                        }
+                    }
+                }
+            }
         }
         return changes;
     }

package/dist/domain/strategies/sync/V2ProjectSyncStrategy.d.ts

@@ -0,0 +1,80 @@
+/**
+ * V2ProjectSyncStrategy - Handles synchronization in newo_v2 format
+ *
+ * Uses the SAME V1 API endpoints as ProjectSyncStrategy but writes/reads
+ * files in the newo_v2 directory layout:
+ *   {CustomerIdn}/
+ *     import_version.txt
+ *     {ProjectIdn}/
+ *       {project_idn}.yaml
+ *       agents/{AgentIdn}/
+ *         agent.yaml
+ *         flows/{FlowIdn}/
+ *           {FlowIdn}.yaml  (inline skill defs, events, state_fields)
+ *           skills/{SkillIdn}.nsl|.nslg
+ */
+import type { ISyncStrategy, PullOptions, PullResult, PushResult, ChangeItem, ValidationResult, StatusSummary } from './ISyncStrategy.js';
+import type { CustomerConfig, ILogger } from '../../resources/common/types.js';
+import type { ProjectMeta } from '../../../types.js';
+import type { LocalProjectData, ApiClientFactory } from './ProjectSyncStrategy.js';
+/**
+ * V2ProjectSyncStrategy - same API, newo_v2 file layout
+ */
+export declare class V2ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProjectData> {
+    private apiClientFactory;
+    private logger;
+    readonly resourceType = "projects";
+    readonly displayName = "Projects (newo_v2)";
+    constructor(apiClientFactory: ApiClientFactory, logger: ILogger);
+    pull(customer: CustomerConfig, options?: PullOptions): Promise<PullResult<LocalProjectData>>;
+    /**
+     * Pull a single agent in V2 format
+     */
+    private pullAgent;
+    /**
+     * Pull a single flow in V2 format
+     *
+     * In V2, the flow YAML contains inline skill definitions, events, and state_fields.
+     * Skills are written to flows/{FlowIdn}/skills/{SkillIdn}.nsl|.nslg
+     */
+    private pullFlow;
+    /**
+     * Pull a single skill script in V2 format
+     *
+     * Script goes to: flows/{FlowIdn}/skills/{SkillIdn}.nsl|.nslg
+     * No separate metadata.yaml - metadata is inline in the flow YAML
+     */
+    private pullSkill;
+    /**
+     * Pull a library and its skills in V2 format
+     *
+     * Writes:
+     *   {project}/libraries/{lib}/{lib}.yaml (with inline skill list)
+     *   {project}/libraries/{lib}/skills/{skill}.nsl|.nslg
+     */
+    private pullLibrary;
+    push(customer: CustomerConfig, changes?: ChangeItem<LocalProjectData>[]): Promise<PushResult>;
+    /**
+     * Push a V2 skill update
+     *
+     * V2 path: newo_customers/{cust}/{proj}/agents/{agent}/flows/{flow}/skills/{skill}.nsl
+     */
+    private pushV2SkillUpdate;
+    /**
+     * Push a V2 library skill update
+     * Path: .../newo_customers/{cust}/{proj}/libraries/{lib}/skills/{skillFile}
+     */
+    private pushV2LibrarySkillUpdate;
+    /**
+     * Publish all flows
+     */
+    private publishAllFlows;
+    getChanges(customer: CustomerConfig): Promise<ChangeItem<LocalProjectData>[]>;
+    validate(customer: CustomerConfig, _items: LocalProjectData[]): Promise<ValidationResult>;
+    getStatus(customer: CustomerConfig): Promise<StatusSummary>;
+}
+/**
+ * Factory function for creating V2ProjectSyncStrategy
+ */
+export declare function createV2ProjectSyncStrategy(apiClientFactory: ApiClientFactory, logger: ILogger): V2ProjectSyncStrategy;
+//# sourceMappingURL=V2ProjectSyncStrategy.d.ts.map