newo 2.0.5 → 3.0.0

package/src/sync/status.ts

@@ -10,7 +10,10 @@ import {
   skillMetadataPath,
   customerAttributesPath,
   customerAttributesBackupPath,
-  flowsYamlPath
+  flowsYamlPath,
+  projectDir,
+  agentMetadataPath,
+  flowMetadataPath
 } from '../fsutil.js';
 import {
   validateSkillFolder,
@@ -32,6 +35,122 @@ function isLegacyProjectMap(x: unknown): x is LegacyProjectMap {
   return typeof x === 'object' && x !== null && 'projectId' in x && 'agents' in x;
 }
 
+/**
+ * Scan filesystem for local-only entities not in the project map yet
+ */
+async function scanForLocalOnlyEntities(customer: CustomerConfig, projects: Record<string, ProjectData>, verbose: boolean = false): Promise<{ agentCount: number; flowCount: number; skillCount: number; entities: Array<{ type: 'agent' | 'flow' | 'skill'; path: string; idn: string; projectIdn: string; agentIdn?: string; flowIdn?: string }> }> {
+  const localEntities: Array<{ type: 'agent' | 'flow' | 'skill'; path: string; idn: string; projectIdn: string; agentIdn?: string; flowIdn?: string }> = [];
+  let agentCount = 0;
+  let flowCount = 0;
+  let skillCount = 0;
+
+  // Scan each project directory
+  for (const [projectIdn] of Object.entries(projects)) {
+    const projDir = projectDir(customer.idn, projectIdn);
+    if (!(await fs.pathExists(projDir))) continue;
+
+    if (verbose) console.log(`🔍 Scanning project directory: ${projDir}`);
+
+    // Get all subdirectories in the project (these should be agents)
+    const agentDirs = await fs.readdir(projDir);
+
+    for (const agentIdn of agentDirs) {
+      const agentPath = `${projDir}/${agentIdn}`;
+      const agentStat = await fs.stat(agentPath);
+
+      // Skip files, only process directories
+      if (!agentStat.isDirectory()) continue;
+
+      // Skip if it's not really an agent directory (no metadata.yaml)
+      const agentMetaPath = agentMetadataPath(customer.idn, projectIdn, agentIdn);
+      if (!(await fs.pathExists(agentMetaPath))) continue;
+
+      // Check if this agent is already in the project map
+      const projectData = projects[projectIdn];
+      if (!projectData?.agents[agentIdn]) {
+        // This is a local-only agent!
+        localEntities.push({
+          type: 'agent',
+          path: agentMetaPath,
+          idn: agentIdn,
+          projectIdn
+        });
+        agentCount++;
+        if (verbose) console.log(`  🆕 Found local-only agent: ${agentIdn}`);
+      }
+
+      // Now scan for flows within this agent (regardless of whether agent is local-only or not)
+      try {
+        const flowDirs = await fs.readdir(agentPath);
+        for (const flowIdn of flowDirs) {
+          const flowPath = `${agentPath}/${flowIdn}`;
+          const flowStat = await fs.stat(flowPath);
+
+          // Skip files, only process directories
+          if (!flowStat.isDirectory()) continue;
+
+          // Skip if it's not really a flow directory (no metadata.yaml)
+          const flowMetaPath = flowMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn);
+          if (!(await fs.pathExists(flowMetaPath))) continue;
+
+          // Check if this flow exists in the project map
+          const agentData = projectData?.agents[agentIdn];
+          if (!agentData?.flows[flowIdn]) {
+            // This is a local-only flow!
+            localEntities.push({
+              type: 'flow',
+              path: flowMetaPath,
+              idn: flowIdn,
+              projectIdn,
+              agentIdn
+            });
+            flowCount++;
+            if (verbose) console.log(`    🆕 Found local-only flow: ${agentIdn}/${flowIdn}`);
+          }
+
+          // Now scan for skills within this flow (regardless of whether flow is local-only or not)
+          try {
+            const skillDirs = await fs.readdir(flowPath);
+            for (const skillIdn of skillDirs) {
+              const skillPath = `${flowPath}/${skillIdn}`;
+              const skillStat = await fs.stat(skillPath);
+
+              // Skip files, only process directories
+              if (!skillStat.isDirectory()) continue;
+
+              // Skip if it's not really a skill directory (no metadata.yaml)
+              const skillMetaPath = skillMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn);
+              if (!(await fs.pathExists(skillMetaPath))) continue;
+
+              // Check if this skill exists in the project map
+              const flowData = agentData?.flows[flowIdn];
+              if (!flowData?.skills[skillIdn]) {
+                // This is a local-only skill!
+                localEntities.push({
+                  type: 'skill',
+                  path: skillMetaPath,
+                  idn: skillIdn,
+                  projectIdn,
+                  agentIdn,
+                  flowIdn
+                });
+                skillCount++;
+                if (verbose) console.log(`      🆕 Found local-only skill: ${agentIdn}/${flowIdn}/${skillIdn}`);
+              }
+            }
+          } catch (error) {
+            // Ignore errors reading flow directory
+          }
+        }
+      } catch (error) {
+        // Ignore errors reading agent directory
+      }
+    }
+  }
+
+  return { agentCount, flowCount, skillCount, entities: localEntities };
+}
+
 /**
  * Check status of files for a customer
  */
@@ -54,6 +173,69 @@ export async function status(customer: CustomerConfig, verbose: boolean = false)
     ? { '': idMapData as ProjectData }
     : (() => { throw new Error('Invalid project map format'); })();
 
+  // First, scan for any local-only entities (created locally but not yet pushed)
+  const localScan = await scanForLocalOnlyEntities(customer, projects, verbose);
+  const totalLocalEntities = localScan.agentCount + localScan.flowCount + localScan.skillCount;
+
+  if (totalLocalEntities > 0) {
+    dirty += totalLocalEntities;
+
+    for (const entity of localScan.entities) {
+      if (entity.type === 'agent') {
+        console.log(`A  ${entity.projectIdn}/${entity.idn}/metadata.yaml (new agent)`);
+        if (verbose) {
+          try {
+            const metadataContent = await fs.readFile(entity.path, 'utf8');
+            const metadata = yaml.load(metadataContent) as any;
+            console.log(`    📊 New Agent: ${entity.idn}`);
+            if (metadata?.title && metadata.title !== entity.idn) {
+              console.log(`      • Title: ${metadata.title}`);
+            }
+            if (metadata?.description) {
+              console.log(`      • Description: ${metadata.description}`);
+            }
+          } catch (e) {
+            // Ignore parsing errors
+          }
+        }
+      } else if (entity.type === 'flow') {
+        console.log(`A  ${entity.projectIdn}/${entity.agentIdn}/${entity.idn}/metadata.yaml (new flow)`);
+        if (verbose) {
+          try {
+            const metadataContent = await fs.readFile(entity.path, 'utf8');
+            const metadata = yaml.load(metadataContent) as any;
+            console.log(`    📊 New Flow: ${entity.idn}`);
+            if (metadata?.title && metadata.title !== entity.idn) {
+              console.log(`      • Title: ${metadata.title}`);
+            }
+            if (metadata?.default_runner_type) {
+              console.log(`      • Runner: ${metadata.default_runner_type}`);
+            }
+          } catch (e) {
+            // Ignore parsing errors
+          }
+        }
+      } else if (entity.type === 'skill') {
+        console.log(`A  ${entity.projectIdn}/${entity.agentIdn}/${entity.flowIdn}/${entity.idn}/metadata.yaml (new skill)`);
+        if (verbose) {
+          try {
+            const metadataContent = await fs.readFile(entity.path, 'utf8');
+            const metadata = yaml.load(metadataContent) as any;
+            console.log(`    📊 New Skill: ${entity.idn}`);
+            if (metadata?.title && metadata.title !== entity.idn) {
+              console.log(`      • Title: ${metadata.title}`);
+            }
+            if (metadata?.runner_type) {
+              console.log(`      • Runner: ${metadata.runner_type}`);
+            }
+          } catch (e) {
+            // Ignore parsing errors
+          }
+        }
+      }
+    }
+  }
+
   for (const [projectIdn, projectData] of Object.entries(projects)) {
     if (verbose && projectIdn) console.log(`📁 Checking project: ${projectIdn}`);
 

package/src/types.ts

@@ -306,8 +306,7 @@ export interface AgentMetadata {
   idn: string;
   title?: string;
   description?: string;
-  // Additional agent settings from UI could be added here
-  persona?: string;
+  persona_id?: string | null;
   created_at?: string;
   updated_at?: string;
 }
@@ -449,4 +448,125 @@ export interface ConversationsData {
   readonly total_personas: number;
   readonly total_acts: number;
   readonly generated_at: string;
+}
+
+// Entity Creation/Deletion Types
+
+export interface CreateAgentRequest {
+  idn: string;
+  title: string;
+  description?: string | null;
+  persona_id?: string | null;
+}
+
+export interface CreateAgentResponse {
+  id: string;
+}
+
+export interface CreateFlowRequest {
+  idn: string;
+  title: string;
+}
+
+export interface CreateFlowResponse {
+  id: string;
+}
+
+export interface CreateSkillRequest {
+  idn: string;
+  title: string;
+  prompt_script?: string;
+  runner_type: RunnerType;
+  model: ModelConfig;
+  path?: string;
+  parameters?: SkillParameter[];
+}
+
+export interface CreateSkillResponse {
+  id: string;
+}
+
+export interface CreateFlowEventRequest {
+  idn: string;
+  description?: string;
+  skill_selector: string;
+  skill_idn?: string;
+  state_idn?: string | null;
+  interrupt_mode: string;
+  integration_idn: string;
+  connector_idn: string;
+}
+
+export interface CreateFlowEventResponse {
+  id: string;
+}
+
+export interface CreateFlowStateRequest {
+  title: string;
+  idn: string;
+  default_value?: string;
+  scope: string;
+}
+
+export interface CreateFlowStateResponse {
+  id: string;
+}
+
+export interface CreateSkillParameterRequest {
+  name: string;
+  default_value?: string;
+}
+
+export interface CreateSkillParameterResponse {
+  id: string;
+}
+
+export interface CreateCustomerAttributeRequest {
+  idn: string;
+  value: string;
+  title: string;
+  description?: string;
+  group: string;
+  is_hidden: boolean;
+  possible_values: string[];
+  value_type: string;
+}
+
+export interface CreateCustomerAttributeResponse {
+  id: string;
+}
+
+export interface CreatePersonaRequest {
+  name: string;
+  title: string;
+  description?: string;
+}
+
+export interface CreatePersonaResponse {
+  id: string;
+}
+
+export interface CreateProjectRequest {
+  idn: string;
+  title: string;
+  version?: string;
+  description?: string;
+  is_auto_update_enabled?: boolean;
+  registry_idn?: string;
+  registry_item_idn?: string | null;
+  registry_item_version?: string | null;
+}
+
+export interface CreateProjectResponse {
+  id: string;
+}
+
+export interface PublishFlowRequest {
+  version: string;
+  description: string;
+  type: string;
+}
+
+export interface PublishFlowResponse {
+  success: boolean;
 }