newo 1.2.0

package/.env.example

@@ -0,0 +1,18 @@
+# NEWO endpoints
+NEWO_BASE_URL=https://app.newo.ai
+
+# Project you want to sync
+NEWO_PROJECT_ID=b78188ba-0df0-46a8-8713-f0d7cff0a06e
+
+# Auth (choose one)
+# 1) Recommended: API key that can be exchanged for tokens:
+NEWO_API_KEY=put_api_key_here
+
+# 2) Optional bootstrap tokens (used if present)
+NEWO_ACCESS_TOKEN=
+NEWO_REFRESH_TOKEN=
+
+# Optional: explicit refresh endpoint if your server supports it (else leave blank)
+NEWO_REFRESH_URL=
+# Example:
+# NEWO_REFRESH_URL=https://app.newo.ai/api/v1/auth/token/refresh

package/README.md

@@ -0,0 +1,79 @@
+# NEWO CLI
+
+Mirror NEWO "Project → Agent → Flow → Skills" to local files and back, Git-first.
+
+## Install
+```bash
+npm install
+```
+
+## Configure
+```bash
+cp .env.example .env
+# Edit .env with your values
+```
+Required:
+- `NEWO_BASE_URL` (default `https://app.newo.ai`)
+- `NEWO_PROJECT_ID`
+- One of:
+  - `NEWO_API_KEY` to exchange for tokens (recommended), or
+  - `NEWO_ACCESS_TOKEN` (+ optional `NEWO_REFRESH_TOKEN` and `NEWO_REFRESH_URL`)
+
+## Commands
+```bash
+npx newo pull     # download project -> ./project
+npx newo status   # list modified files
+npx newo push     # upload modified *.guidance/*.jinja back to NEWO
+```
+
+Files are stored as:
+- `./project/<AgentIdn>/<FlowIdn>/<SkillIdn>.guidance` (AI guidance scripts)
+- `./project/<AgentIdn>/<FlowIdn>/<SkillIdn>.jinja` (NSL/Jinja template scripts)
+
+Hashes are tracked in `.newo/hashes.json` so only changed files are pushed.
+Project structure is also exported to `flows.yaml` for reference.
+
+## Features
+- **Two-way sync**: Pull NEWO projects to local files, push local changes back
+- **Change detection**: SHA256 hashing prevents unnecessary uploads
+- **Multiple file types**: `.guidance` (AI prompts) and `.jinja` (NSL templates)
+- **Project structure export**: Generates `flows.yaml` with complete project metadata
+- **Robust authentication**: API key exchange with automatic token refresh
+- **CI/CD ready**: GitHub Actions workflow included
+
+## CI/CD (GitHub Actions)
+Create `.github/workflows/deploy.yml`:
+```yaml
+name: Deploy NEWO Skills
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - 'project/**/*.guidance'
+      - 'project/**/*.jinja'
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: node ./src/cli.js push
+        env:
+          NEWO_BASE_URL: https://app.newo.ai
+          NEWO_PROJECT_ID: b78188ba-0df0-46a8-8713-f0d7cff0a06e
+          NEWO_API_KEY: ${{ secrets.NEWO_API_KEY }}
+          # Optional:
+          # NEWO_REFRESH_URL: ${{ secrets.NEWO_REFRESH_URL }}
+```
+
+## API Endpoints
+- `GET /api/v1/bff/agents/list?project_id=...` - List project agents
+- `GET /api/v1/designer/flows/{flowId}/skills` - List skills in flow
+- `GET /api/v1/designer/skills/{skillId}` - Get skill content
+- `PUT /api/v1/designer/flows/skills/{skillId}` - Update skill content
+- `GET /api/v1/designer/flows/{flowId}/events` - List flow events (for flows.yaml)
+- `GET /api/v1/designer/flows/{flowId}/states` - List flow states (for flows.yaml)
+- `POST /api/v1/auth/api-key/token` - Exchange API key for access tokens

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "newo",
+  "version": "1.2.0",
+  "description": "NEWO CLI: sync flows/skills between NEWO and local files",
+  "type": "module",
+  "bin": {
+    "newo": "./src/cli.js"
+  },
+  "files": [
+    "src/**/*.js",
+    "README.md",
+    ".env.example"
+  ],
+  "keywords": [
+    "newo",
+    "cli",
+    "ai",
+    "agent",
+    "automation",
+    "sync",
+    "local-development"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/newo-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/newo-cli/issues"
+  },
+  "homepage": "https://github.com/yourusername/newo-cli#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "axios": "^1.7.7",
+    "dotenv": "^16.4.5",
+    "fs-extra": "^11.2.0",
+    "js-yaml": "^4.1.0",
+    "minimist": "^1.2.8"
+  },
+  "scripts": {
+    "dev": "node ./src/cli.js",
+    "pull": "node ./src/cli.js pull",
+    "push": "node ./src/cli.js push",
+    "status": "node ./src/cli.js status"
+  }
+}

package/src/api.js

@@ -0,0 +1,93 @@
+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;
+}

package/src/auth.js

@@ -0,0 +1,92 @@
+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/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import dotenv from 'dotenv';
+import { makeClient, getProjectMeta } from './api.js';
+import { pullAll, pushChanged, status } from './sync.js';
+
+dotenv.config();
+const { NEWO_PROJECT_ID } = process.env;
+
+async function main() {
+  const args = minimist(process.argv.slice(2));
+  const cmd = args._[0];
+  const verbose = args.verbose || args.v;
+
+  if (!cmd || ['help', '-h', '--help'].includes(cmd)) {
+    console.log(`NEWO CLI
+Usage:
+  newo pull           # download project -> ./project
+  newo push           # upload modified *.guidance/*.jinja back to NEWO
+  newo status         # show modified files
+  newo meta           # get project metadata (debug)
+  
+Flags:
+  --verbose, -v       # enable detailed logging
+  
+Env:
+  NEWO_BASE_URL, NEWO_PROJECT_ID, NEWO_API_KEY, NEWO_REFRESH_URL (optional)
+`);
+    return;
+  }
+
+  const client = await makeClient(verbose);
+
+  if (cmd === 'pull') {
+    if (!NEWO_PROJECT_ID) throw new Error('NEWO_PROJECT_ID is not set in env');
+    await pullAll(client, NEWO_PROJECT_ID, verbose);
+  } else if (cmd === 'push') {
+    await pushChanged(client, verbose);
+  } else if (cmd === 'status') {
+    await status(verbose);
+  } else if (cmd === 'meta') {
+    if (!NEWO_PROJECT_ID) throw new Error('NEWO_PROJECT_ID is not set in env');
+    const meta = await getProjectMeta(client, NEWO_PROJECT_ID);
+    console.log(JSON.stringify(meta, null, 2));
+  } else {
+    console.error('Unknown command:', cmd);
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error(e?.response?.data || e);
+  process.exit(1);
+});

package/src/fsutil.js

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,17 @@
+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 });
+}

package/src/sync.js

@@ -0,0 +1,284 @@
+import { listAgents, listFlowSkills, updateSkill, listFlowEvents, listFlowStates } from './api.js';
+import { ensureState, skillPath, writeFileAtomic, readIfExists, MAP_PATH } from './fsutil.js';
+import fs from 'fs-extra';
+import { sha256, loadHashes, saveHashes } from './hash.js';
+import yaml from 'js-yaml';
+import path from 'path';
+
+export async function pullAll(client, projectId, verbose = false) {
+  await ensureState();
+  if (verbose) console.log(`🔍 Fetching agents for project ${projectId}...`);
+  const agents = await listAgents(client, projectId);
+  if (verbose) console.log(`📦 Found ${agents.length} agents`);
+
+  const idMap = { projectId, agents: {} };
+
+  for (const agent of agents) {
+    const aKey = agent.idn;
+    idMap.agents[aKey] = { id: agent.id, flows: {} };
+
+    for (const flow of agent.flows ?? []) {
+      idMap.agents[aKey].flows[flow.idn] = { id: flow.id, skills: {} };
+
+      const skills = await listFlowSkills(client, flow.id);
+      for (const s of skills) {
+        const file = skillPath(agent.idn, flow.idn, s.idn, s.runner_type);
+        await writeFileAtomic(file, s.prompt_script || '');
+        // Store complete skill metadata for push operations
+        idMap.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
+        };
+        console.log(`✓ Pulled ${file}`);
+      }
+    }
+  }
+
+  await fs.writeJson(MAP_PATH, idMap, { spaces: 2 });
+
+  // Generate flows.yaml
+  if (verbose) console.log('📄 Generating flows.yaml...');
+  await generateFlowsYaml(client, agents, verbose);
+
+  const hashes = {};
+  for (const [agentIdn, agentObj] of Object.entries(idMap.agents)) {
+    for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+      for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
+        const p = skillPath(agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+        const content = await fs.readFile(p, 'utf8');
+        hashes[p] = sha256(content);
+      }
+    }
+  }
+  await saveHashes(hashes);
+}
+
+export async function pushChanged(client, verbose = false) {
+  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);
+  if (verbose) console.log('🔍 Loading file hashes...');
+  const oldHashes = await loadHashes();
+  const newHashes = { ...oldHashes };
+
+  if (verbose) console.log('🔄 Scanning for changes...');
+  let pushed = 0;
+  let scanned = 0;
+  
+  for (const [agentIdn, agentObj] of Object.entries(idMap.agents)) {
+    if (verbose) console.log(`  📁 Scanning agent: ${agentIdn}`);
+    for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+      if (verbose) console.log(`    📁 Scanning flow: ${flowIdn}`);
+      for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
+        const p = skillPath(agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+        scanned++;
+        if (verbose) console.log(`      📄 Checking: ${p}`);
+        
+        const content = await readIfExists(p);
+        if (content === null) {
+          if (verbose) console.log(`        ⚠️  File not found: ${p}`);
+          continue;
+        }
+        
+        const h = sha256(content);
+        const oldHash = oldHashes[p];
+        if (verbose) {
+          console.log(`        🔍 Hash comparison:`);
+          console.log(`          Old: ${oldHash || 'none'}`);
+          console.log(`          New: ${h}`);
+        }
+        
+        if (oldHash !== h) {
+          if (verbose) console.log(`        🔄 File changed, preparing to push...`);
+          
+          // Create complete skill object with updated prompt_script
+          const skillObject = {
+            id: skillMeta.id,
+            title: skillMeta.title,
+            idn: skillMeta.idn,
+            prompt_script: content,
+            runner_type: skillMeta.runner_type,
+            model: skillMeta.model,
+            parameters: skillMeta.parameters,
+            path: skillMeta.path
+          };
+          
+          if (verbose) {
+            console.log(`        📤 Pushing skill object:`);
+            console.log(`          ID: ${skillObject.id}`);
+            console.log(`          Title: ${skillObject.title}`);
+            console.log(`          IDN: ${skillObject.idn}`);
+            console.log(`          Content length: ${content.length} chars`);
+            console.log(`          Content preview: ${content.substring(0, 100).replace(/\n/g, '\\n')}...`);
+          }
+          
+          await updateSkill(client, skillObject);
+          console.log(`↑ Pushed ${p}`);
+          newHashes[p] = h;
+          pushed++;
+        } else if (verbose) {
+          console.log(`        ✓ No changes`);
+        }
+      }
+    }
+  }
+
+  if (verbose) console.log(`🔄 Scanned ${scanned} files, found ${pushed} changes`);
+  await saveHashes(newHashes);
+  console.log(pushed ? `✅ Push complete. ${pushed} file(s) updated.` : '✅ Nothing to push.');
+}
+
+export async function status(verbose = false) {
+  await ensureState();
+  if (!(await fs.pathExists(MAP_PATH))) {
+    console.log('No map. Run `newo pull` first.');
+    return;
+  }
+  
+  if (verbose) console.log('📋 Loading project mapping and hashes...');
+  const idMap = await fs.readJson(MAP_PATH);
+  const hashes = await loadHashes();
+  let dirty = 0;
+
+  for (const [agentIdn, agentObj] of Object.entries(idMap.agents)) {
+    if (verbose) console.log(`  📁 Checking agent: ${agentIdn}`);
+    for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+      if (verbose) console.log(`    📁 Checking flow: ${flowIdn}`);
+      for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
+        const p = skillPath(agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+        const exists = await fs.pathExists(p);
+        if (!exists) { 
+          console.log(`D  ${p}`); 
+          dirty++; 
+          if (verbose) console.log(`      ❌ Deleted: ${p}`);
+          continue; 
+        }
+        const content = await fs.readFile(p, 'utf8');
+        const h = sha256(content);
+        const oldHash = hashes[p];
+        if (verbose) {
+          console.log(`      📄 ${p}`);
+          console.log(`        Old hash: ${oldHash || 'none'}`);
+          console.log(`        New hash: ${h}`);
+        }
+        if (oldHash !== h) { 
+          console.log(`M  ${p}`); 
+          dirty++; 
+          if (verbose) console.log(`      🔄 Modified: ${p}`);
+        } else if (verbose) {
+          console.log(`      ✓ Unchanged: ${p}`);
+        }
+      }
+    }
+  }
+  console.log(dirty ? `${dirty} changed file(s).` : 'Clean.');
+}
+
+async function generateFlowsYaml(client, agents, verbose = false) {
+  const flowsData = { flows: [] };
+
+  for (const agent of agents) {
+    if (verbose) console.log(`  📁 Processing agent: ${agent.idn}`);
+    
+    const agentFlows = [];
+    
+    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 => ({
+        idn: skill.idn,
+        title: skill.title || "",
+        prompt_script: `flows/${flow.idn}/${skill.idn}.${skill.runner_type === 'nsl' ? 'jinja' : 'nsl'}`,
+        runner_type: `!enum "RunnerType.${skill.runner_type}"`,
+        model: {
+          model_idn: skill.model.model_idn,
+          provider_idn: skill.model.provider_idn
+        },
+        parameters: skill.parameters.map(param => ({
+          name: param.name,
+          default_value: param.default_value || " "
+        }))
+      }));
+
+      // Get events for this flow
+      let eventsData = [];
+      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,
+          interrupt_mode: `!enum "InterruptMode.${event.interrupt_mode}"`
+        }));
+        if (verbose) console.log(`      📋 Found ${events.length} events`);
+      } catch (error) {
+        if (verbose) console.log(`      ⚠️  No events found for flow ${flow.idn}`);
+      }
+
+      // Get state fields for this flow
+      let stateFieldsData = [];
+      try {
+        const states = await listFlowStates(client, flow.id);
+        stateFieldsData = states.map(state => ({
+          title: state.title,
+          idn: state.idn,
+          default_value: state.default_value,
+          scope: `!enum "StateFieldScope.${state.scope}"`
+        }));
+        if (verbose) console.log(`      📊 Found ${states.length} state fields`);
+      } catch (error) {
+        if (verbose) console.log(`      ⚠️  No state fields found for flow ${flow.idn}`);
+      }
+
+      agentFlows.push({
+        idn: flow.idn,
+        title: flow.title,
+        description: flow.description || null,
+        default_runner_type: `!enum "RunnerType.${flow.default_runner_type}"`,
+        default_provider_idn: flow.default_model.provider_idn,
+        default_model_idn: flow.default_model.model_idn,
+        skills: skillsData,
+        events: eventsData,
+        state_fields: stateFieldsData
+      });
+    }
+
+    flowsData.flows.push({
+      agent_idn: agent.idn,
+      agent_description: agent.description,
+      agent_flows: agentFlows
+    });
+  }
+
+  // Convert to YAML and write to file with custom enum handling
+  let yamlContent = yaml.dump(flowsData, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false,
+    quotingType: '"',
+    forceQuotes: false
+  });
+  
+  // Post-process to fix enum formatting
+  yamlContent = yamlContent.replace(/"(!enum "[^"]+")"/g, '$1');
+  
+  const yamlPath = path.join('flows.yaml');
+  await fs.writeFile(yamlPath, yamlContent, 'utf8');
+  console.log(`✓ Generated flows.yaml`);
+}