newo 3.4.1 → 3.6.0

package/src/cli-new/bootstrap.ts

@@ -11,6 +11,8 @@ import { ConsoleLogger, type ILogger, type CustomerConfig, type MultiCustomerCon
 import { SyncEngine, type SyncEngineOptions } from '../application/sync/SyncEngine.js';
 import { MigrationEngine, TransformService } from '../application/migration/MigrationEngine.js';
 import { ProjectSyncStrategy, createProjectSyncStrategy } from '../domain/strategies/sync/ProjectSyncStrategy.js';
+import { createV2ProjectSyncStrategy } from '../domain/strategies/sync/V2ProjectSyncStrategy.js';
+import type { FormatVersion } from '../format/types.js';
 import { AttributeSyncStrategy, createAttributeSyncStrategy } from '../domain/strategies/sync/AttributeSyncStrategy.js';
 import { IntegrationSyncStrategy, createIntegrationSyncStrategy } from '../domain/strategies/sync/IntegrationSyncStrategy.js';
 import { AkbSyncStrategy, createAkbSyncStrategy } from '../domain/strategies/sync/AkbSyncStrategy.js';
@@ -30,7 +32,7 @@ export async function createApiClient(customer: CustomerConfig, verbose: boolean
     process.env.NEWO_PROJECT_ID = customer.projectId;
   }
 
-  const token = await getValidAccessToken();
+  const token = await getValidAccessToken(customer);
   return makeClient(verbose, token);
 }
 
@@ -47,6 +49,12 @@ export interface BootstrapOptions {
    * Sync engine options
    */
   syncEngineOptions?: SyncEngineOptions;
+
+  /**
+   * Format version for project sync strategy
+   * 'newo_v2' uses V2ProjectSyncStrategy, 'cli_v1' (default) uses ProjectSyncStrategy
+   */
+  formatVersion?: FormatVersion | undefined;
 }
 
 /**
@@ -73,10 +81,13 @@ export function createServiceContainer(
 
   // === Domain Layer - Sync Strategies ===
 
-  // Project Sync Strategy
-  container.registerSingleton(TOKENS.PROJECT_SYNC_STRATEGY, () =>
-    createProjectSyncStrategy(createApiClient, container.get<ILogger>(TOKENS.LOGGER))
-  );
+  // Project Sync Strategy (format-conditional: cli_v1 or newo_v2)
+  container.registerSingleton(TOKENS.PROJECT_SYNC_STRATEGY, () => {
+    if (options.formatVersion === 'newo_v2') {
+      return createV2ProjectSyncStrategy(createApiClient, container.get<ILogger>(TOKENS.LOGGER));
+    }
+    return createProjectSyncStrategy(createApiClient, container.get<ILogger>(TOKENS.LOGGER));
+  });
 
   // Attribute Sync Strategy
   container.registerSingleton(TOKENS.ATTRIBUTE_SYNC_STRATEGY, () =>
@@ -151,14 +162,15 @@ export function getLogger(container: ServiceContainer): ILogger {
  */
 export function setupCli(
   customerConfig: MultiCustomerConfig,
-  verbose: boolean = false
+  verbose: boolean = false,
+  formatVersion?: FormatVersion
 ): {
   container: ServiceContainer;
   syncEngine: SyncEngine;
   migrationEngine: MigrationEngine;
   logger: ILogger;
 } {
-  const container = createServiceContainer(customerConfig, { verbose });
+  const container = createServiceContainer(customerConfig, { verbose, formatVersion });
 
   return {
     container,

package/src/cli-new/di/tokens.ts

@@ -64,6 +64,7 @@ export const TOKENS = {
   // Configuration
   CUSTOMER_CONFIG: Symbol('CustomerConfig'),
   ENVIRONMENT: Symbol('Environment'),
+  FORMAT_VERSION: Symbol('FormatVersion'),
 } as const;
 
 /**

package/src/cli.ts

@@ -29,6 +29,7 @@ import { handleCreateStateCommand } from './cli/commands/create-state.js';
 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 { handleUpdateAttributeCommand } from './cli/commands/update-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';
@@ -45,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';
 import type { CliArgs, NewoApiError } from './types.js';
 
 dotenv.config();
@@ -110,6 +112,10 @@ async function main(): Promise<void> {
         await handleLogsCommand(customerConfig, args, verbose);
         break;
 
+      case 'export':
+        await handleExportCommand(customerConfig, args, verbose);
+        break;
+
       case 'conversations':
         await handleConversationsCommand(customerConfig, args, verbose);
         break;
@@ -182,6 +188,10 @@ async function main(): Promise<void> {
         await handleCreateAttributeCommand(customerConfig, args, verbose);
         break;
 
+      case 'update-attribute':
+        await handleUpdateAttributeCommand(customerConfig, args, verbose);
+        break;
+
       case 'pull-integrations':
         await handlePullIntegrationsCommand(customerConfig, args, verbose);
         break;

package/src/domain/strategies/sync/ProjectSyncStrategy.ts

@@ -46,7 +46,9 @@ import {
   listFlowEvents,
   listFlowStates,
   updateSkill,
-  publishFlow
+  publishFlow,
+  listLibraries,
+  updateLibrarySkill,
 } from '../../../api.js';
 import {
   ensureState,
@@ -60,7 +62,10 @@ import {
   skillFolderPath,
   flowsYamlPath,
   customerProjectsDir,
-  projectDir
+  projectDir,
+  libraryMetadataPath,
+  librarySkillMetadataPath,
+  librarySkillScriptPath,
 } from '../../../fsutil.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 import { generateFlowsYaml } from '../../../sync/metadata.js';
@@ -241,6 +246,52 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
         }
       }
 
+      // 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: SkillMetadata = {
+                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);
     }
@@ -489,11 +540,15 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     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;
         }
@@ -563,6 +618,40 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     return 1;
   }
 
+  /**
+   * Push a library skill update
+   * Path: newo_customers/{customer}/projects/{project}/libraries/{lib}/{skill}/{skill}.jinja
+   */
+  private async pushLibrarySkillUpdate(
+    client: AxiosInstance,
+    change: ChangeItem<LocalProjectData>,
+    mapData: ProjectMap,
+    newHashes: HashStore
+  ): Promise<number> {
+    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
    */
@@ -616,7 +705,7 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     const hashes = await loadHashes(customer.idn);
     const mapData = await fs.readJson(mapFile) as ProjectMap;
 
-    // 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)) {
@@ -629,7 +718,7 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
 
               if (storedHash !== currentHash) {
                 changes.push({
-                  item: {} as LocalProjectData, // Simplified for now
+                  item: {} as LocalProjectData,
                   operation: 'modified',
                   path: skillFile.filePath
                 });
@@ -638,6 +727,31 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
           }
         }
       }
+
+      // 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: {} as LocalProjectData,
+                  operation: 'modified',
+                  path: scriptPath
+                });
+              }
+            }
+          }
+        }
+      }
     }
 
     return changes;