newo 3.4.0 → 3.4.2

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

@@ -0,0 +1,152 @@
+/**
+ * Dependency Injection Container
+ *
+ * A simple, TypeScript-native DI container that:
+ * - Supports singleton and factory registrations
+ * - Provides type-safe dependency resolution
+ * - Enables easy testing through dependency injection
+ */
+
+/**
+ * Factory function type for creating service instances
+ */
+type Factory<T> = (container: ServiceContainer) => T;
+
+/**
+ * Registration types
+ */
+interface Registration<T> {
+  factory: Factory<T>;
+  singleton: boolean;
+  instance?: T;
+}
+
+/**
+ * Service Container for Dependency Injection
+ */
+export class ServiceContainer {
+  private registrations: Map<symbol, Registration<unknown>> = new Map();
+
+  /**
+   * Register a factory that creates a new instance each time
+   */
+  register<T>(token: symbol, factory: Factory<T>): void {
+    this.registrations.set(token, {
+      factory,
+      singleton: false
+    });
+  }
+
+  /**
+   * Register a singleton - only created once
+   */
+  registerSingleton<T>(token: symbol, instanceOrFactory: T | Factory<T>): void {
+    if (typeof instanceOrFactory === 'function') {
+      this.registrations.set(token, {
+        factory: instanceOrFactory as Factory<T>,
+        singleton: true
+      });
+    } else {
+      this.registrations.set(token, {
+        factory: () => instanceOrFactory,
+        singleton: true,
+        instance: instanceOrFactory
+      });
+    }
+  }
+
+  /**
+   * Register a value directly
+   */
+  registerValue<T>(token: symbol, value: T): void {
+    this.registrations.set(token, {
+      factory: () => value,
+      singleton: true,
+      instance: value
+    });
+  }
+
+  /**
+   * Resolve a service by its token
+   */
+  get<T>(token: symbol): T {
+    const registration = this.registrations.get(token);
+
+    if (!registration) {
+      throw new Error(`No registration found for token: ${token.toString()}`);
+    }
+
+    if (registration.singleton) {
+      if (registration.instance === undefined) {
+        registration.instance = registration.factory(this);
+      }
+      return registration.instance as T;
+    }
+
+    return registration.factory(this) as T;
+  }
+
+  /**
+   * Check if a token is registered
+   */
+  has(token: symbol): boolean {
+    return this.registrations.has(token);
+  }
+
+  /**
+   * Get all registered tokens
+   */
+  getTokens(): symbol[] {
+    return Array.from(this.registrations.keys());
+  }
+
+  /**
+   * Clear all registrations (useful for testing)
+   */
+  clear(): void {
+    this.registrations.clear();
+  }
+
+  /**
+   * Create a child container that inherits parent registrations
+   */
+  createChild(): ServiceContainer {
+    const child = new ServiceContainer();
+
+    // Copy parent registrations
+    for (const [token, registration] of this.registrations) {
+      child.registrations.set(token, { ...registration });
+    }
+
+    return child;
+  }
+}
+
+/**
+ * Global container instance
+ */
+let globalContainer: ServiceContainer | null = null;
+
+/**
+ * Get the global container instance
+ */
+export function getContainer(): ServiceContainer {
+  if (!globalContainer) {
+    globalContainer = new ServiceContainer();
+  }
+  return globalContainer;
+}
+
+/**
+ * Set the global container instance (useful for testing)
+ */
+export function setContainer(container: ServiceContainer): void {
+  globalContainer = container;
+}
+
+/**
+ * Reset the global container (useful for testing)
+ */
+export function resetContainer(): void {
+  globalContainer = null;
+}

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

@@ -0,0 +1,105 @@
+/**
+ * Dependency Injection Tokens
+ *
+ * These symbols are used as unique identifiers for services in the DI container.
+ * Using symbols ensures no naming conflicts.
+ */
+
+// Infrastructure Layer
+export const TOKENS = {
+  // Logging
+  LOGGER: Symbol('Logger'),
+
+  // Auth
+  AUTH_SERVICE: Symbol('AuthService'),
+
+  // API Client
+  API_CLIENT: Symbol('ApiClient'),
+  API_CLIENT_FACTORY: Symbol('ApiClientFactory'),
+
+  // File System
+  FILE_SYSTEM: Symbol('FileSystem'),
+  HASH_MANAGER: Symbol('HashManager'),
+  METADATA_GENERATOR: Symbol('MetadataGenerator'),
+
+  // Repositories
+  PROJECT_REPOSITORY: Symbol('ProjectRepository'),
+  INTEGRATION_REPOSITORY: Symbol('IntegrationRepository'),
+  AKB_REPOSITORY: Symbol('AkbRepository'),
+  ATTRIBUTE_REPOSITORY: Symbol('AttributeRepository'),
+  CONVERSATION_REPOSITORY: Symbol('ConversationRepository'),
+
+  // Domain Layer - Sync Strategies
+  PROJECT_SYNC_STRATEGY: Symbol('ProjectSyncStrategy'),
+  INTEGRATION_SYNC_STRATEGY: Symbol('IntegrationSyncStrategy'),
+  AKB_SYNC_STRATEGY: Symbol('AkbSyncStrategy'),
+  ATTRIBUTE_SYNC_STRATEGY: Symbol('AttributeSyncStrategy'),
+  CONVERSATION_SYNC_STRATEGY: Symbol('ConversationSyncStrategy'),
+
+  // Domain Layer - Entity Strategies
+  PROJECT_ENTITY_STRATEGY: Symbol('ProjectEntityStrategy'),
+  AGENT_ENTITY_STRATEGY: Symbol('AgentEntityStrategy'),
+  FLOW_ENTITY_STRATEGY: Symbol('FlowEntityStrategy'),
+  SKILL_ENTITY_STRATEGY: Symbol('SkillEntityStrategy'),
+
+  // Application Layer - Engines
+  SYNC_ENGINE: Symbol('SyncEngine'),
+  MIGRATION_ENGINE: Symbol('MigrationEngine'),
+  ENTITY_MANAGER: Symbol('EntityManager'),
+
+  // Application Layer - Use Cases
+  PULL_USE_CASE: Symbol('PullUseCase'),
+  PUSH_USE_CASE: Symbol('PushUseCase'),
+  STATUS_USE_CASE: Symbol('StatusUseCase'),
+  MIGRATE_USE_CASE: Symbol('MigrateUseCase'),
+  CREATE_ENTITY_USE_CASE: Symbol('CreateEntityUseCase'),
+  DELETE_ENTITY_USE_CASE: Symbol('DeleteEntityUseCase'),
+
+  // CLI Layer
+  COMMAND_REGISTRY: Symbol('CommandRegistry'),
+  COMMAND_EXECUTOR: Symbol('CommandExecutor'),
+  ERROR_HANDLER: Symbol('ErrorHandler'),
+  CUSTOMER_SELECTOR: Symbol('CustomerSelector'),
+
+  // Configuration
+  CUSTOMER_CONFIG: Symbol('CustomerConfig'),
+  ENVIRONMENT: Symbol('Environment'),
+} as const;
+
+/**
+ * Type for the tokens object
+ */
+export type TokenKey = keyof typeof TOKENS;
+export type Token = (typeof TOKENS)[TokenKey];
+
+/**
+ * Resource types for selective sync
+ * These match the resourceType property in each ISyncStrategy implementation
+ */
+export const RESOURCE_TYPES = {
+  PROJECTS: 'projects',
+  ATTRIBUTES: 'attributes',
+  INTEGRATIONS: 'integrations',
+  AKB: 'akb',
+  CONVERSATIONS: 'conversations',
+} as const;
+
+/**
+ * All available resource types for sync operations
+ */
+export const ALL_RESOURCE_TYPES = Object.values(RESOURCE_TYPES);
+
+/**
+ * Pushable resource types (excludes read-only resources like conversations)
+ */
+export const PUSHABLE_RESOURCE_TYPES = ['projects', 'attributes', 'integrations', 'akb'] as const;
+
+/**
+ * Type for resource type values
+ */
+export type ResourceType = (typeof RESOURCE_TYPES)[keyof typeof RESOURCE_TYPES];
+
+/**
+ * Type for pushable resource types
+ */
+export type PushableResourceType = (typeof PUSHABLE_RESOURCE_TYPES)[number];

package/src/cli.ts

@@ -23,11 +23,13 @@ import { handleDeleteFlowCommand } from './cli/commands/delete-flow.js';
 import { handleCreateSkillCommand } from './cli/commands/create-skill.js';
 import { handleDeleteSkillCommand } from './cli/commands/delete-skill.js';
 import { handleCreateProjectCommand } from './cli/commands/create-project.js';
+import { handleCreateCustomerCommand } from './cli/commands/create-customer.js';
 import { handleCreateEventCommand } from './cli/commands/create-event.js';
 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';
@@ -41,6 +43,9 @@ import { handleCreateWebhooksCommand } from './cli/commands/create-webhooks.js';
 import { handleListRegistriesCommand } from './cli/commands/list-registries.js';
 import { handleListRegistryItemsCommand } from './cli/commands/list-registry-items.js';
 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 type { CliArgs, NewoApiError } from './types.js';
 
 dotenv.config();
@@ -102,6 +107,10 @@ async function main(): Promise<void> {
         await handleStatusCommand(customerConfig, args, verbose);
         break;
 
+      case 'logs':
+        await handleLogsCommand(customerConfig, args, verbose);
+        break;
+
       case 'conversations':
         await handleConversationsCommand(customerConfig, args, verbose);
         break;
@@ -150,6 +159,10 @@ async function main(): Promise<void> {
         await handleCreateProjectCommand(customerConfig, args, verbose);
         break;
 
+      case 'create-customer':
+        await handleCreateCustomerCommand(customerConfig, args, verbose);
+        break;
+
       case 'create-event':
         await handleCreateEventCommand(customerConfig, args, verbose);
         break;
@@ -170,6 +183,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;
@@ -219,6 +236,14 @@ async function main(): Promise<void> {
         await handleAddProjectCommand(customerConfig, args, verbose);
         break;
 
+      case 'watch':
+        await handleWatchCommand(customerConfig, args, verbose);
+        break;
+
+      case 'diff':
+        await handleDiffCommand(customerConfig, args, verbose);
+        break;
+
       default:
         console.error('Unknown command:', cmd);
         console.error('Run "newo --help" for usage information');

package/src/domain/resources/common/types.ts

@@ -0,0 +1,106 @@
+/**
+ * Common types used across all domain resources
+ */
+
+/**
+ * Customer configuration for API operations
+ */
+export interface CustomerConfig {
+  idn: string;
+  apiKey: string;
+  projectId?: string | undefined;
+}
+
+/**
+ * Multi-customer configuration
+ */
+export interface MultiCustomerConfig {
+  customers: Record<string, CustomerConfig>;
+  defaultCustomer?: string | undefined;
+}
+
+/**
+ * Base entity interface with common fields
+ */
+export interface BaseEntity {
+  id: string;
+  idn: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+/**
+ * Entity with title and description
+ */
+export interface DescriptiveEntity extends BaseEntity {
+  title: string;
+  description?: string;
+}
+
+/**
+ * Hash store for change detection
+ */
+export interface HashStore {
+  [filePath: string]: string;
+}
+
+/**
+ * ID mapping for local to remote entity references
+ */
+export interface IdMapping {
+  [localId: string]: string;
+}
+
+/**
+ * Logger interface for dependency injection
+ */
+export interface ILogger {
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, error?: unknown): void;
+  debug(message: string, ...args: unknown[]): void;
+  verbose(message: string, ...args: unknown[]): void;
+  progress(current: number, total: number, message: string): void;
+}
+
+/**
+ * Default console logger implementation
+ */
+export class ConsoleLogger implements ILogger {
+  constructor(private verboseMode: boolean = false) {}
+
+  info(message: string, ..._args: unknown[]): void {
+    console.log(message);
+  }
+
+  warn(message: string, ..._args: unknown[]): void {
+    console.warn(`⚠️  ${message}`);
+  }
+
+  error(message: string, error?: unknown): void {
+    console.error(`❌ ${message}`);
+    if (error && this.verboseMode) {
+      console.error(error);
+    }
+  }
+
+  debug(message: string, ..._args: unknown[]): void {
+    if (this.verboseMode) {
+      console.log(`🔍 ${message}`);
+    }
+  }
+
+  verbose(message: string, ..._args: unknown[]): void {
+    if (this.verboseMode) {
+      console.log(message);
+    }
+  }
+
+  progress(current: number, total: number, message: string): void {
+    const pct = Math.round((current / total) * 100);
+    process.stdout.write(`\r${message}: ${current}/${total} (${pct}%)`);
+    if (current === total) {
+      console.log('');
+    }
+  }
+}