newo 1.3.0 → 1.5.0

package/dist/types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * 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;
+}
+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;
+}
+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;
+}
+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';
+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>;
+}
+export interface LegacyProjectMap extends ProjectData {
+    projects?: Record<string, ProjectData>;
+}
+export interface HashStore {
+    [filePath: string]: string;
+}
+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;
+}
+export interface CliArgs {
+    _: string[];
+    verbose?: boolean;
+    v?: boolean;
+    [key: string]: unknown;
+}
+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[];
+}
+export interface AxiosClientConfig {
+    baseURL?: string;
+    headers?: Record<string, string>;
+}
+export interface NewoApiError extends Error {
+    response?: {
+        status: number;
+        data: unknown;
+    };
+    config?: {
+        method?: string;
+        url?: string;
+        headers?: Record<string, string>;
+    };
+}
+export type FileStatus = 'M' | 'D' | 'clean';
+export interface StatusResult {
+    filePath: string;
+    status: FileStatus;
+    oldHash?: string;
+    newHash?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Comprehensive type definitions for NEWO CLI
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "newo",
-  "version": "1.3.0",
-  "description": "NEWO CLI: sync flows/skills between NEWO and local files, import AKB articles",
+  "version": "1.5.0",
+  "description": "NEWO CLI: sync flows/skills between NEWO and local files, multi-project support, import AKB articles",
   "type": "module",
   "bin": {
-    "newo": "src/cli.js"
+    "newo": "dist/cli.js"
   },
   "files": [
-    "src/**/*.js",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "src/**/*.ts",
     "README.md",
     "CHANGELOG.md",
     ".env.example"
@@ -22,7 +24,9 @@
     "local-development",
     "akb",
     "knowledge-base",
-    "import"
+    "import",
+    "multi-project",
+    "workspace"
   ],
   "author": "sabbah13",
   "license": "MIT",
@@ -44,10 +48,29 @@
     "js-yaml": "^4.1.0",
     "minimist": "^1.2.8"
   },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^22.5.4",
+    "mocha": "^10.2.0",
+    "typescript": "^5.6.2"
+  },
   "scripts": {
-    "dev": "node ./src/cli.js",
-    "pull": "node ./src/cli.js pull",
-    "push": "node ./src/cli.js push",
-    "status": "node ./src/cli.js status"
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "dev": "npm run build && node ./dist/cli.js",
+    "dev:watch": "tsc --watch & nodemon --watch dist dist/cli.js",
+    "pull": "npm run build && node ./dist/cli.js pull",
+    "push": "npm run build && node ./dist/cli.js push",
+    "status": "npm run build && node ./dist/cli.js status",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit --strict",
+    "test": "npm run build && mocha test/*.test.js --timeout 60000",
+    "test:api": "npm run build && mocha test/api.test.js --timeout 30000",
+    "test:sync": "npm run build && mocha test/sync.test.js --timeout 60000",
+    "test:integration": "npm run build && mocha test/integration.test.js --timeout 120000",
+    "prepublishOnly": "npm run clean && npm run build"
   }
 }

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

@@ -1,13 +1,12 @@
 import fs from 'fs-extra';
+import type { ParsedArticle, AkbImportArticle } from './types.js';
 
 /**
  * Parse AKB file and extract articles
- * @param {string} filePath - Path to AKB file
- * @returns {Array} Array of parsed articles
  */
-function parseAkbFile(filePath) {
+export function parseAkbFile(filePath: string): ParsedArticle[] {
   const content = fs.readFileSync(filePath, 'utf8');
-  const articles = [];
+  const articles: ParsedArticle[] = [];
   
   // Split by article separators (---)
   const sections = content.split(/^---\s*$/gm).filter(section => section.trim());
@@ -27,10 +26,8 @@ function parseAkbFile(filePath) {
 
 /**
  * Parse individual article section
- * @param {Array} lines - Lines of the article section
- * @returns {Object|null} Parsed article object
  */
-function parseArticleSection(lines) {
+function parseArticleSection(lines: string[]): ParsedArticle | null {
   let topicName = '';
   let category = '';
   let summary = '';
@@ -53,7 +50,7 @@ function parseArticleSection(lines) {
   const summaryLineIndex = lines.findIndex(line => line.startsWith('## ') && line.includes(' / '));
   if (summaryLineIndex >= 0 && summaryLineIndex + 1 < lines.length) {
     const nextLine = lines[summaryLineIndex + 1];
-    if (nextLine.startsWith('## ') && !nextLine.includes(' / ')) {
+    if (nextLine && nextLine.startsWith('## ') && !nextLine.includes(' / ')) {
       summary = nextLine.replace(/^##\s+/, '').trim();
     }
   }
@@ -63,7 +60,10 @@ function parseArticleSection(lines) {
     index > summaryLineIndex + 1 && line.startsWith('## ') && !line.includes(' / ')
   );
   if (keywordsLineIndex >= 0) {
-    keywords = lines[keywordsLineIndex].replace(/^##\s+/, '').trim();
+    const keywordsLine = lines[keywordsLineIndex];
+    if (keywordsLine) {
+      keywords = keywordsLine.replace(/^##\s+/, '').trim();
+    }
   }
   
   // Extract category content
@@ -76,11 +76,7 @@ function parseArticleSection(lines) {
   }
   
   // Create topic_facts array
-  const topicFacts = [
-    category,
-    summary,
-    keywords
-  ].filter(fact => fact.trim() !== '');
+  const topicFacts = [category, summary, keywords].filter(fact => fact.trim() !== '');
   
   return {
     topic_name: category, // Use the descriptive title as topic_name
@@ -89,24 +85,19 @@ function parseArticleSection(lines) {
     topic_facts: topicFacts,
     confidence: 100,
     source: topicName, // Use the ID (r001) as source
-    labels: ["rag_context"]
+    labels: ['rag_context']
   };
 }
 
 /**
  * Convert parsed articles to API format for bulk import
- * @param {Array} articles - Parsed articles
- * @param {string} personaId - Target persona ID
- * @returns {Array} Array of articles ready for API import
  */
-function prepareArticlesForImport(articles, personaId) {
+export function prepareArticlesForImport(
+  articles: ParsedArticle[], 
+  personaId: string
+): AkbImportArticle[] {
   return articles.map(article => ({
     ...article,
     persona_id: personaId
   }));
-}
-
-export {
-  parseAkbFile,
-  prepareArticlesForImport
-};
+}

package/src/api.ts

@@ -0,0 +1,127 @@
+import axios, { type AxiosInstance, type InternalAxiosRequestConfig, type AxiosResponse, type AxiosError } from 'axios';
+import dotenv from 'dotenv';
+import { getValidAccessToken, forceReauth } from './auth.js';
+import type { 
+  NewoEnvironment, 
+  ProjectMeta, 
+  Agent, 
+  Skill, 
+  FlowEvent, 
+  FlowState,
+  AkbImportArticle
+} from './types.js';
+
+dotenv.config();
+
+const { NEWO_BASE_URL } = process.env as NewoEnvironment;
+
+export async function makeClient(verbose: boolean = false): Promise<AxiosInstance> {
+  let accessToken = await getValidAccessToken();
+  if (verbose) console.log('✓ Access token obtained');
+
+  if (!NEWO_BASE_URL) {
+    throw new Error('NEWO_BASE_URL is not set in environment variables');
+  }
+
+  const client = axios.create({
+    baseURL: NEWO_BASE_URL,
+    headers: { accept: 'application/json' }
+  });
+
+  client.interceptors.request.use(async (config: InternalAxiosRequestConfig) => {
+    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(
+    (response: AxiosResponse) => {
+      if (verbose) {
+        console.log(`← ${response.status} ${response.config.method?.toUpperCase()} ${response.config.url}`);
+        if (response.data && Object.keys(response.data).length < 20) {
+          console.log('  Response:', JSON.stringify(response.data, null, 2));
+        } else if (response.data) {
+          console.log(`  Response: [${typeof response.data}] ${Array.isArray(response.data) ? response.data.length + ' items' : 'large object'}`);
+        }
+      }
+      return response;
+    },
+    async (error: AxiosError) => {
+      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();
+        
+        if (error.config) {
+          error.config.headers = error.config.headers || {};
+          error.config.headers.Authorization = `Bearer ${accessToken}`;
+          return client.request(error.config);
+        }
+      }
+      
+      throw error;
+    }
+  );
+
+  return client;
+}
+
+export async function listProjects(client: AxiosInstance): Promise<ProjectMeta[]> {
+  const response = await client.get<ProjectMeta[]>('/api/v1/designer/projects');
+  return response.data;
+}
+
+export async function listAgents(client: AxiosInstance, projectId: string): Promise<Agent[]> {
+  const response = await client.get<Agent[]>('/api/v1/bff/agents/list', { 
+    params: { project_id: projectId } 
+  });
+  return response.data;
+}
+
+export async function getProjectMeta(client: AxiosInstance, projectId: string): Promise<ProjectMeta> {
+  const response = await client.get<ProjectMeta>(`/api/v1/designer/projects/by-id/${projectId}`);
+  return response.data;
+}
+
+export async function listFlowSkills(client: AxiosInstance, flowId: string): Promise<Skill[]> {
+  const response = await client.get<Skill[]>(`/api/v1/designer/flows/${flowId}/skills`);
+  return response.data;
+}
+
+export async function getSkill(client: AxiosInstance, skillId: string): Promise<Skill> {
+  const response = await client.get<Skill>(`/api/v1/designer/skills/${skillId}`);
+  return response.data;
+}
+
+export async function updateSkill(client: AxiosInstance, skillObject: Skill): Promise<void> {
+  await client.put(`/api/v1/designer/flows/skills/${skillObject.id}`, skillObject);
+}
+
+export async function listFlowEvents(client: AxiosInstance, flowId: string): Promise<FlowEvent[]> {
+  const response = await client.get<FlowEvent[]>(`/api/v1/designer/flows/${flowId}/events`);
+  return response.data;
+}
+
+export async function listFlowStates(client: AxiosInstance, flowId: string): Promise<FlowState[]> {
+  const response = await client.get<FlowState[]>(`/api/v1/designer/flows/${flowId}/states`);
+  return response.data;
+}
+
+export async function importAkbArticle(client: AxiosInstance, articleData: AkbImportArticle): Promise<unknown> {
+  const response = await client.post('/api/v1/akb/append-manual', articleData);
+  return response.data;
+}

package/src/auth.ts

@@ -0,0 +1,142 @@
+import fs from 'fs-extra';
+import path from 'path';
+import axios from 'axios';
+import dotenv from 'dotenv';
+import type { NewoEnvironment, TokenResponse, StoredTokens } from './types.js';
+
+dotenv.config();
+
+const {
+  NEWO_BASE_URL,
+  NEWO_API_KEY,
+  NEWO_ACCESS_TOKEN,
+  NEWO_REFRESH_TOKEN,
+  NEWO_REFRESH_URL
+} = process.env as NewoEnvironment;
+
+const STATE_DIR = path.join(process.cwd(), '.newo');
+const TOKENS_PATH = path.join(STATE_DIR, 'tokens.json');
+
+async function saveTokens(tokens: StoredTokens): Promise<void> {
+  await fs.ensureDir(STATE_DIR);
+  await fs.writeJson(TOKENS_PATH, tokens, { spaces: 2 });
+}
+
+async function loadTokens(): Promise<StoredTokens | null> {
+  if (await fs.pathExists(TOKENS_PATH)) {
+    return fs.readJson(TOKENS_PATH) as Promise<StoredTokens>;
+  }
+  
+  if (NEWO_ACCESS_TOKEN || NEWO_REFRESH_TOKEN) {
+    const tokens: StoredTokens = {
+      access_token: NEWO_ACCESS_TOKEN || '',
+      refresh_token: NEWO_REFRESH_TOKEN || '',
+      expires_at: Date.now() + 10 * 60 * 1000
+    };
+    await saveTokens(tokens);
+    return tokens;
+  }
+  
+  return null;
+}
+
+function isExpired(tokens: StoredTokens | null): boolean {
+  if (!tokens?.expires_at) return false;
+  return Date.now() >= tokens.expires_at - 10_000;
+}
+
+export async function exchangeApiKeyForToken(): Promise<StoredTokens> {
+  if (!NEWO_API_KEY) {
+    throw new Error('NEWO_API_KEY not set. Provide an API key in .env');
+  }
+  
+  const url = `${NEWO_BASE_URL}/api/v1/auth/api-key/token`;
+  const response = await axios.post<TokenResponse>(
+    url, 
+    {}, 
+    { 
+      headers: { 
+        'x-api-key': NEWO_API_KEY, 
+        'accept': 'application/json' 
+      } 
+    }
+  );
+  
+  const data = response.data;
+  const access = data.access_token || data.token || data.accessToken;
+  const refresh = data.refresh_token || data.refreshToken || '';
+  const expiresInSec = data.expires_in || data.expiresIn || 3600;
+  
+  if (!access) {
+    throw new Error('Failed to get access token from API key exchange');
+  }
+  
+  const tokens: StoredTokens = { 
+    access_token: access, 
+    refresh_token: refresh, 
+    expires_at: Date.now() + expiresInSec * 1000 
+  };
+  
+  await saveTokens(tokens);
+  return tokens;
+}
+
+export async function refreshWithEndpoint(refreshToken: string): Promise<StoredTokens> {
+  if (!NEWO_REFRESH_URL) {
+    throw new Error('NEWO_REFRESH_URL not set');
+  }
+  
+  const response = await axios.post<TokenResponse>(
+    NEWO_REFRESH_URL, 
+    { refresh_token: refreshToken }, 
+    { headers: { 'accept': 'application/json' } }
+  );
+  
+  const data = response.data;
+  const access = data.access_token || data.token || data.accessToken;
+  const refresh = data.refresh_token ?? refreshToken;
+  const expiresInSec = data.expires_in || 3600;
+  
+  if (!access) {
+    throw new Error('Failed to get access token from refresh');
+  }
+  
+  const tokens: StoredTokens = { 
+    access_token: access, 
+    refresh_token: refresh, 
+    expires_at: Date.now() + expiresInSec * 1000 
+  };
+  
+  await saveTokens(tokens);
+  return tokens;
+}
+
+export async function getValidAccessToken(): Promise<string> {
+  let tokens = await loadTokens();
+  
+  if (!tokens || !tokens.access_token) {
+    tokens = await exchangeApiKeyForToken();
+    return tokens.access_token;
+  }
+  
+  if (!isExpired(tokens)) {
+    return tokens.access_token;
+  }
+
+  if (NEWO_REFRESH_URL && tokens.refresh_token) {
+    try {
+      tokens = await refreshWithEndpoint(tokens.refresh_token);
+      return tokens.access_token;
+    } catch (error) {
+      console.warn('Refresh failed, falling back to API key exchange…');
+    }
+  }
+  
+  tokens = await exchangeApiKeyForToken();
+  return tokens.access_token;
+}
+
+export async function forceReauth(): Promise<string> {
+  const tokens = await exchangeApiKeyForToken();
+  return tokens.access_token;
+}