newo 1.4.0 → 1.5.0

package/src/{sync.js → sync.ts}

@@ -1,11 +1,46 @@
-import { listProjects, listAgents, listFlowSkills, updateSkill, listFlowEvents, listFlowStates, getProjectMeta } from './api.js';
-import { ensureState, skillPath, writeFileAtomic, readIfExists, MAP_PATH, projectDir, metadataPath } from './fsutil.js';
+import { 
+  listProjects, 
+  listAgents, 
+  listFlowSkills, 
+  updateSkill, 
+  listFlowEvents, 
+  listFlowStates, 
+  getProjectMeta 
+} from './api.js';
+import { 
+  ensureState, 
+  skillPath, 
+  writeFileAtomic, 
+  readIfExists, 
+  MAP_PATH, 
+  projectDir, 
+  metadataPath 
+} from './fsutil.js';
 import fs from 'fs-extra';
 import { sha256, loadHashes, saveHashes } from './hash.js';
 import yaml from 'js-yaml';
 import path from 'path';
+import type { AxiosInstance } from 'axios';
+import type { 
+  Agent, 
+  ProjectData, 
+  ProjectMap, 
+  LegacyProjectMap,
+  HashStore,
+  FlowsYamlData,
+  FlowsYamlAgent,
+  FlowsYamlFlow,
+  FlowsYamlSkill,
+  FlowsYamlEvent,
+  FlowsYamlState
+} from './types.js';
 
-export async function pullSingleProject(client, projectId, projectIdn, verbose = false) {
+export async function pullSingleProject(
+  client: AxiosInstance, 
+  projectId: string, 
+  projectIdn: string, 
+  verbose: boolean = false
+): Promise<ProjectData> {
   if (verbose) console.log(`🔍 Fetching agents for project ${projectId} (${projectIdn})...`);
   const agents = await listAgents(client, projectId);
   if (verbose) console.log(`📦 Found ${agents.length} agents`);
@@ -15,28 +50,29 @@ export async function pullSingleProject(client, projectId, projectIdn, verbose =
   await writeFileAtomic(metadataPath(projectIdn), JSON.stringify(projectMeta, null, 2));
   if (verbose) console.log(`✓ Saved metadata for ${projectIdn}`);
 
-  const projectMap = { projectId, projectIdn, agents: {} };
+  const projectMap: ProjectData = { projectId, projectIdn, agents: {} };
 
   for (const agent of agents) {
     const aKey = agent.idn;
     projectMap.agents[aKey] = { id: agent.id, flows: {} };
 
     for (const flow of agent.flows ?? []) {
-      projectMap.agents[aKey].flows[flow.idn] = { id: flow.id, skills: {} };
+      projectMap.agents[aKey]!.flows[flow.idn] = { id: flow.id, skills: {} };
 
       const skills = await listFlowSkills(client, flow.id);
-      for (const s of skills) {
-        const file = skillPath(projectIdn, agent.idn, flow.idn, s.idn, s.runner_type);
-        await writeFileAtomic(file, s.prompt_script || '');
+      for (const skill of skills) {
+        const file = skillPath(projectIdn, agent.idn, flow.idn, skill.idn, skill.runner_type);
+        await writeFileAtomic(file, skill.prompt_script || '');
+        
         // Store complete skill metadata for push operations
-        projectMap.agents[aKey].flows[flow.idn].skills[s.idn] = {
-          id: s.id,
-          title: s.title,
-          idn: s.idn,
-          runner_type: s.runner_type,
-          model: s.model,
-          parameters: s.parameters,
-          path: s.path
+        projectMap.agents[aKey]!.flows[flow.idn]!.skills[skill.idn] = {
+          id: skill.id,
+          title: skill.title,
+          idn: skill.idn,
+          runner_type: skill.runner_type,
+          model: skill.model,
+          parameters: skill.parameters,
+          path: skill.path || undefined
         };
         console.log(`✓ Pulled ${file}`);
       }
@@ -50,7 +86,11 @@ export async function pullSingleProject(client, projectId, projectIdn, verbose =
   return projectMap;
 }
 
-export async function pullAll(client, projectId = null, verbose = false) {
+export async function pullAll(
+  client: AxiosInstance, 
+  projectId: string | null = null, 
+  verbose: boolean = false
+): Promise<void> {
   await ensureState();
   
   if (projectId) {
@@ -58,11 +98,11 @@ export async function pullAll(client, projectId = null, verbose = false) {
     const projectMeta = await getProjectMeta(client, projectId);
     const projectMap = await pullSingleProject(client, projectId, projectMeta.idn, verbose);
     
-    const idMap = { projects: { [projectMeta.idn]: projectMap } };
+    const idMap: ProjectMap = { projects: { [projectMeta.idn]: projectMap } };
     await fs.writeJson(MAP_PATH, idMap, { spaces: 2 });
     
     // Generate hash tracking for this project
-    const hashes = {};
+    const hashes: HashStore = {};
     for (const [agentIdn, agentObj] of Object.entries(projectMap.agents)) {
       for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
         for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
@@ -77,12 +117,12 @@ export async function pullAll(client, projectId = null, verbose = false) {
   }
 
   // Multi-project mode
-  if (verbose) console.log(`🔍 Fetching all projects...`);
+  if (verbose) console.log('🔍 Fetching all projects...');
   const projects = await listProjects(client);
   if (verbose) console.log(`📦 Found ${projects.length} projects`);
 
-  const idMap = { projects: {} };
-  const allHashes = {};
+  const idMap: ProjectMap = { projects: {} };
+  const allHashes: HashStore = {};
 
   for (const project of projects) {
     if (verbose) console.log(`\n📁 Processing project: ${project.idn} (${project.title})`);
@@ -105,24 +145,24 @@ export async function pullAll(client, projectId = null, verbose = false) {
   await saveHashes(allHashes);
 }
 
-export async function pushChanged(client, verbose = false) {
+export async function pushChanged(client: AxiosInstance, verbose: boolean = false): Promise<void> {
   await ensureState();
   if (!(await fs.pathExists(MAP_PATH))) {
     throw new Error('Missing .newo/map.json. Run `newo pull` first.');
   }
   
   if (verbose) console.log('📋 Loading project mapping...');
-  const idMap = await fs.readJson(MAP_PATH);
+  const idMap = await fs.readJson(MAP_PATH) as ProjectMap | LegacyProjectMap;
   if (verbose) console.log('🔍 Loading file hashes...');
   const oldHashes = await loadHashes();
-  const newHashes = { ...oldHashes };
+  const newHashes: HashStore = { ...oldHashes };
 
   if (verbose) console.log('🔄 Scanning for changes...');
   let pushed = 0;
   let scanned = 0;
   
   // Handle both old single-project format and new multi-project format
-  const projects = idMap.projects || { '': idMap };
+  const projects = 'projects' in idMap && idMap.projects ? idMap.projects : { '': idMap as ProjectData };
   
   for (const [projectIdn, projectData] of Object.entries(projects)) {
     if (verbose && projectIdn) console.log(`📁 Scanning project: ${projectIdn}`);
@@ -164,7 +204,7 @@ export async function pushChanged(client, verbose = false) {
               runner_type: skillMeta.runner_type,
               model: skillMeta.model,
               parameters: skillMeta.parameters,
-              path: skillMeta.path
+              path: skillMeta.path || undefined
             };
             
             if (verbose) {
@@ -193,7 +233,7 @@ export async function pushChanged(client, verbose = false) {
   console.log(pushed ? `✅ Push complete. ${pushed} file(s) updated.` : '✅ Nothing to push.');
 }
 
-export async function status(verbose = false) {
+export async function status(verbose: boolean = false): Promise<void> {
   await ensureState();
   if (!(await fs.pathExists(MAP_PATH))) {
     console.log('No map. Run `newo pull` first.');
@@ -201,12 +241,12 @@ export async function status(verbose = false) {
   }
   
   if (verbose) console.log('📋 Loading project mapping and hashes...');
-  const idMap = await fs.readJson(MAP_PATH);
+  const idMap = await fs.readJson(MAP_PATH) as ProjectMap | LegacyProjectMap;
   const hashes = await loadHashes();
   let dirty = 0;
 
   // Handle both old single-project format and new multi-project format
-  const projects = idMap.projects || { '': idMap };
+  const projects = 'projects' in idMap && idMap.projects ? idMap.projects : { '': idMap as ProjectData };
 
   for (const [projectIdn, projectData] of Object.entries(projects)) {
     if (verbose && projectIdn) console.log(`📁 Checking project: ${projectIdn}`);
@@ -248,20 +288,25 @@ export async function status(verbose = false) {
   console.log(dirty ? `${dirty} changed file(s).` : 'Clean.');
 }
 
-async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
-  const flowsData = { flows: [] };
+async function generateFlowsYaml(
+  client: AxiosInstance, 
+  agents: Agent[], 
+  projectIdn: string, 
+  verbose: boolean = false
+): Promise<void> {
+  const flowsData: FlowsYamlData = { flows: [] };
 
   for (const agent of agents) {
     if (verbose) console.log(`  📁 Processing agent: ${agent.idn}`);
     
-    const agentFlows = [];
+    const agentFlows: FlowsYamlFlow[] = [];
     
     for (const flow of agent.flows ?? []) {
       if (verbose) console.log(`    📄 Processing flow: ${flow.idn}`);
       
       // Get skills for this flow
       const skills = await listFlowSkills(client, flow.id);
-      const skillsData = skills.map(skill => ({
+      const skillsData: FlowsYamlSkill[] = skills.map(skill => ({
         idn: skill.idn,
         title: skill.title || "",
         prompt_script: `flows/${flow.idn}/${skill.idn}.${skill.runner_type === 'nsl' ? 'jinja' : 'nsl'}`,
@@ -277,17 +322,17 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
       }));
 
       // Get events for this flow
-      let eventsData = [];
+      let eventsData: FlowsYamlEvent[] = [];
       try {
         const events = await listFlowEvents(client, flow.id);
         eventsData = events.map(event => ({
           title: event.description,
           idn: event.idn,
           skill_selector: `!enum "SkillSelector.${event.skill_selector}"`,
-          skill_idn: event.skill_idn,
-          state_idn: event.state_idn,
-          integration_idn: event.integration_idn,
-          connector_idn: event.connector_idn,
+          skill_idn: event.skill_idn || undefined,
+          state_idn: event.state_idn || undefined,
+          integration_idn: event.integration_idn || undefined,
+          connector_idn: event.connector_idn || undefined,
           interrupt_mode: `!enum "InterruptMode.${event.interrupt_mode}"`
         }));
         if (verbose) console.log(`      📋 Found ${events.length} events`);
@@ -296,13 +341,13 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
       }
 
       // Get state fields for this flow
-      let stateFieldsData = [];
+      let stateFieldsData: FlowsYamlState[] = [];
       try {
         const states = await listFlowStates(client, flow.id);
         stateFieldsData = states.map(state => ({
           title: state.title,
           idn: state.idn,
-          default_value: state.default_value,
+          default_value: state.default_value || undefined,
           scope: `!enum "StateFieldScope.${state.scope}"`
         }));
         if (verbose) console.log(`      📊 Found ${states.length} state fields`);
@@ -323,11 +368,13 @@ async function generateFlowsYaml(client, agents, projectIdn, verbose = false) {
       });
     }
 
-    flowsData.flows.push({
+    const agentData: FlowsYamlAgent = {
       agent_idn: agent.idn,
-      agent_description: agent.description,
+      agent_description: agent.description || undefined,
       agent_flows: agentFlows
-    });
+    };
+    
+    flowsData.flows.push(agentData);
   }
 
   // Convert to YAML and write to file with custom enum handling

package/src/types.ts

@@ -0,0 +1,248 @@
+/**
+ * Comprehensive type definitions for NEWO CLI
+ */
+
+export interface NewoEnvironment {
+  NEWO_BASE_URL?: string;
+  NEWO_PROJECT_ID?: string;
+  NEWO_API_KEY?: string;
+  NEWO_ACCESS_TOKEN?: string;
+  NEWO_REFRESH_TOKEN?: string;
+  NEWO_REFRESH_URL?: string;
+}
+
+// Authentication Types
+export interface TokenResponse {
+  access_token?: string;
+  token?: string;
+  accessToken?: string;
+  refresh_token?: string;
+  refreshToken?: string;
+  expires_in?: number;
+  expiresIn?: number;
+}
+
+export interface StoredTokens {
+  access_token: string;
+  refresh_token: string;
+  expires_at: number;
+}
+
+// API Response Types
+export interface ProjectMeta {
+  id: string;
+  idn: string;
+  title: string;
+  description?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface Agent {
+  id: string;
+  idn: string;
+  title?: string;
+  description?: string;
+  flows?: Flow[];
+}
+
+export interface Flow {
+  id: string;
+  idn: string;
+  title: string;
+  description?: string;
+  default_runner_type: RunnerType;
+  default_model: ModelConfig;
+}
+
+export interface ModelConfig {
+  model_idn: string;
+  provider_idn: string;
+}
+
+export interface SkillParameter {
+  name: string;
+  default_value?: string;
+}
+
+export interface Skill {
+  id: string;
+  idn: string;
+  title: string;
+  prompt_script?: string;
+  runner_type: RunnerType;
+  model: ModelConfig;
+  parameters: SkillParameter[];
+  path?: string | undefined;
+}
+
+export interface FlowEvent {
+  id: string;
+  idn: string;
+  description: string;
+  skill_selector: SkillSelector;
+  skill_idn?: string;
+  state_idn?: string;
+  integration_idn?: string;
+  connector_idn?: string;
+  interrupt_mode: InterruptMode;
+}
+
+export interface FlowState {
+  id: string;
+  idn: string;
+  title: string;
+  default_value?: string;
+  scope: StateFieldScope;
+}
+
+// Enum Types
+export type RunnerType = 'guidance' | 'nsl';
+export type SkillSelector = 'first' | 'last' | 'random' | 'all';
+export type InterruptMode = 'allow' | 'deny' | 'queue';
+export type StateFieldScope = 'flow' | 'agent' | 'project' | 'global';
+
+// File System Types
+export interface SkillMetadata {
+  id: string;
+  title: string;
+  idn: string;
+  runner_type: RunnerType;
+  model: ModelConfig;
+  parameters: SkillParameter[];
+  path?: string | undefined;
+}
+
+export interface FlowData {
+  id: string;
+  skills: Record<string, SkillMetadata>;
+}
+
+export interface AgentData {
+  id: string;
+  flows: Record<string, FlowData>;
+}
+
+export interface ProjectData {
+  projectId: string;
+  projectIdn: string;
+  agents: Record<string, AgentData>;
+}
+
+export interface ProjectMap {
+  projects: Record<string, ProjectData>;
+}
+
+// Legacy single-project format support
+export interface LegacyProjectMap extends ProjectData {
+  projects?: Record<string, ProjectData>;
+}
+
+export interface HashStore {
+  [filePath: string]: string;
+}
+
+// AKB Types
+export interface ParsedArticle {
+  topic_name: string;
+  persona_id: string | null;
+  topic_summary: string;
+  topic_facts: string[];
+  confidence: number;
+  source: string;
+  labels: string[];
+}
+
+export interface AkbImportArticle extends Omit<ParsedArticle, 'persona_id'> {
+  persona_id: string;
+}
+
+// CLI Types
+export interface CliArgs {
+  _: string[];
+  verbose?: boolean;
+  v?: boolean;
+  [key: string]: unknown;
+}
+
+// flows.yaml Generation Types
+export interface FlowsYamlSkill {
+  idn: string;
+  title: string;
+  prompt_script: string;
+  runner_type: string;
+  model: ModelConfig;
+  parameters: Array<{
+    name: string;
+    default_value: string;
+  }>;
+}
+
+export interface FlowsYamlEvent {
+  title: string;
+  idn: string;
+  skill_selector: string;
+  skill_idn?: string | undefined;
+  state_idn?: string | undefined;
+  integration_idn?: string | undefined;
+  connector_idn?: string | undefined;
+  interrupt_mode: string;
+}
+
+export interface FlowsYamlState {
+  title: string;
+  idn: string;
+  default_value?: string | undefined;
+  scope: string;
+}
+
+export interface FlowsYamlFlow {
+  idn: string;
+  title: string;
+  description: string | null;
+  default_runner_type: string;
+  default_provider_idn: string;
+  default_model_idn: string;
+  skills: FlowsYamlSkill[];
+  events: FlowsYamlEvent[];
+  state_fields: FlowsYamlState[];
+}
+
+export interface FlowsYamlAgent {
+  agent_idn: string;
+  agent_description?: string | undefined;
+  agent_flows: FlowsYamlFlow[];
+}
+
+export interface FlowsYamlData {
+  flows: FlowsYamlAgent[];
+}
+
+// HTTP Client Types
+export interface AxiosClientConfig {
+  baseURL?: string;
+  headers?: Record<string, string>;
+}
+
+// Error Types
+export interface NewoApiError extends Error {
+  response?: {
+    status: number;
+    data: unknown;
+  };
+  config?: {
+    method?: string;
+    url?: string;
+    headers?: Record<string, string>;
+  };
+}
+
+// Status Types
+export type FileStatus = 'M' | 'D' | 'clean';
+
+export interface StatusResult {
+  filePath: string;
+  status: FileStatus;
+  oldHash?: string;
+  newHash?: string;
+}

package/src/api.js

@@ -1,103 +0,0 @@
-import axios from 'axios';
-import dotenv from 'dotenv';
-import { getValidAccessToken, forceReauth } from './auth.js';
-dotenv.config();
-
-const { NEWO_BASE_URL } = process.env;
-
-export async function makeClient(verbose = false) {
-  let accessToken = await getValidAccessToken();
-  if (verbose) console.log('✓ Access token obtained');
-
-  const client = axios.create({
-    baseURL: NEWO_BASE_URL,
-    headers: { accept: 'application/json' }
-  });
-
-  client.interceptors.request.use(async (config) => {
-    config.headers = config.headers || {};
-    config.headers.Authorization = `Bearer ${accessToken}`;
-    if (verbose) {
-      console.log(`→ ${config.method?.toUpperCase()} ${config.url}`);
-      if (config.data) console.log('  Data:', JSON.stringify(config.data, null, 2));
-      if (config.params) console.log('  Params:', config.params);
-    }
-    return config;
-  });
-
-  let retried = false;
-  client.interceptors.response.use(
-    r => {
-      if (verbose) {
-        console.log(`← ${r.status} ${r.config.method?.toUpperCase()} ${r.config.url}`);
-        if (r.data && Object.keys(r.data).length < 20) {
-          console.log('  Response:', JSON.stringify(r.data, null, 2));
-        } else if (r.data) {
-          console.log(`  Response: [${typeof r.data}] ${Array.isArray(r.data) ? r.data.length + ' items' : 'large object'}`);
-        }
-      }
-      return r;
-    },
-    async (error) => {
-      const status = error?.response?.status;
-      if (verbose) {
-        console.log(`← ${status} ${error.config?.method?.toUpperCase()} ${error.config?.url} - ${error.message}`);
-        if (error.response?.data) console.log('  Error data:', error.response.data);
-      }
-      if (status === 401 && !retried) {
-        retried = true;
-        if (verbose) console.log('🔄 Retrying with fresh token...');
-        accessToken = await forceReauth();
-        error.config.headers.Authorization = `Bearer ${accessToken}`;
-        return client.request(error.config);
-      }
-      throw error;
-    }
-  );
-
-  return client;
-}
-
-export async function listProjects(client) {
-  const r = await client.get(`/api/v1/designer/projects`);
-  return r.data;
-}
-
-export async function listAgents(client, projectId) {
-  const r = await client.get(`/api/v1/bff/agents/list`, { params: { project_id: projectId } });
-  return r.data;
-}
-
-export async function getProjectMeta(client, projectId) {
-  const r = await client.get(`/api/v1/designer/projects/by-id/${projectId}`);
-  return r.data;
-}
-
-export async function listFlowSkills(client, flowId) {
-  const r = await client.get(`/api/v1/designer/flows/${flowId}/skills`);
-  return r.data;
-}
-
-export async function getSkill(client, skillId) {
-  const r = await client.get(`/api/v1/designer/skills/${skillId}`);
-  return r.data;
-}
-
-export async function updateSkill(client, skillObject) {
-  await client.put(`/api/v1/designer/flows/skills/${skillObject.id}`, skillObject);
-}
-
-export async function listFlowEvents(client, flowId) {
-  const r = await client.get(`/api/v1/designer/flows/${flowId}/events`);
-  return r.data;
-}
-
-export async function listFlowStates(client, flowId) {
-  const r = await client.get(`/api/v1/designer/flows/${flowId}/states`);
-  return r.data;
-}
-
-export async function importAkbArticle(client, articleData) {
-  const r = await client.post('/api/v1/akb/append-manual', articleData);
-  return r.data;
-}