newo 1.3.0 → 1.5.0

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,98 +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 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;
-}

package/src/auth.js

@@ -1,92 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import axios from 'axios';
-import dotenv from 'dotenv';
-dotenv.config();
-
-const {
-  NEWO_BASE_URL,
-  NEWO_API_KEY,
-  NEWO_ACCESS_TOKEN,
-  NEWO_REFRESH_TOKEN,
-  NEWO_REFRESH_URL
-} = process.env;
-
-const STATE_DIR = path.join(process.cwd(), '.newo');
-const TOKENS_PATH = path.join(STATE_DIR, 'tokens.json');
-
-async function saveTokens(tokens) {
-  await fs.ensureDir(STATE_DIR);
-  await fs.writeJson(TOKENS_PATH, tokens, { spaces: 2 });
-}
-
-async function loadTokens() {
-  if (await fs.pathExists(TOKENS_PATH)) {
-    return fs.readJson(TOKENS_PATH);
-  }
-  if (NEWO_ACCESS_TOKEN || NEWO_REFRESH_TOKEN) {
-    const t = {
-      access_token: NEWO_ACCESS_TOKEN || '',
-      refresh_token: NEWO_REFRESH_TOKEN || '',
-      expires_at: Date.now() + 10 * 60 * 1000
-    };
-    await saveTokens(t);
-    return t;
-  }
-  return null;
-}
-
-function isExpired(tokens) {
-  if (!tokens?.expires_at) return false;
-  return Date.now() >= tokens.expires_at - 10_000;
-}
-
-export async function exchangeApiKeyForToken() {
-  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 res = await axios.post(url, {}, { headers: { 'x-api-key': NEWO_API_KEY, 'accept': 'application/json' } });
-  const data = res.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;
-  const tokens = { access_token: access, refresh_token: refresh, expires_at: Date.now() + expiresInSec * 1000 };
-  await saveTokens(tokens);
-  return tokens;
-}
-
-export async function refreshWithEndpoint(refreshToken) {
-  if (!NEWO_REFRESH_URL) throw new Error('NEWO_REFRESH_URL not set');
-  const res = await axios.post(NEWO_REFRESH_URL, { refresh_token: refreshToken }, { headers: { 'accept': 'application/json' } });
-  const data = res.data || {};
-  const access = data.access_token || data.token || data.accessToken;
-  const refresh = data.refresh_token ?? refreshToken;
-  const expiresInSec = data.expires_in || 3600;
-  const tokens = { access_token: access, refresh_token: refresh, expires_at: Date.now() + expiresInSec * 1000 };
-  await saveTokens(tokens);
-  return tokens;
-}
-
-export async function getValidAccessToken() {
-  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 (e) {
-      console.warn('Refresh failed, falling back to API key exchange…');
-    }
-  }
-  tokens = await exchangeApiKeyForToken();
-  return tokens.access_token;
-}
-
-export async function forceReauth() {
-  const tokens = await exchangeApiKeyForToken();
-  return tokens.access_token;
-}

package/src/fsutil.js

@@ -1,26 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-
-export const ROOT_DIR = path.join(process.cwd(), 'project');
-export const STATE_DIR = path.join(process.cwd(), '.newo');
-export const MAP_PATH = path.join(STATE_DIR, 'map.json');
-export const HASHES_PATH = path.join(STATE_DIR, 'hashes.json');
-
-export async function ensureState() {
-  await fs.ensureDir(STATE_DIR);
-  await fs.ensureDir(ROOT_DIR);
-}
-
-export function skillPath(agentIdn, flowIdn, skillIdn, runnerType = 'guidance') {
-  const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';
-  return path.join(ROOT_DIR, agentIdn, flowIdn, `${skillIdn}${extension}`);
-}
-
-export async function writeFileAtomic(filepath, content) {
-  await fs.ensureDir(path.dirname(filepath));
-  await fs.writeFile(filepath, content, 'utf8');
-}
-
-export async function readIfExists(filepath) {
-  return (await fs.pathExists(filepath)) ? fs.readFile(filepath, 'utf8') : null;
-}

package/src/hash.js

@@ -1,17 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs-extra';
-import { ensureState, HASHES_PATH } from './fsutil.js';
-
-export function sha256(str) {
-  return crypto.createHash('sha256').update(str, 'utf8').digest('hex');
-}
-
-export async function loadHashes() {
-  await ensureState();
-  if (await fs.pathExists(HASHES_PATH)) return fs.readJson(HASHES_PATH);
-  return {};
-}
-
-export async function saveHashes(h) {
-  await fs.writeJson(HASHES_PATH, h, { spaces: 2 });
-}