veogent 1.0.0

package/README.md

@@ -0,0 +1,103 @@
+# 🎬 Veogent CLI <a href="https://veogent.com"><img src="https://veogent.com/favicon.ico" width="24" height="24" align="center" /></a>
+
+**The official Command-Line Interface for the [VEOGENT API](https://veogent.com)**.
+
+Veogent CLI gives you (and your AI Agents) the power to manage full-scale AI video and story projects directly from the terminal. Connect to projects, orchestrate multi-frame scenes, edit image prompts with professional camera cues, and trigger large-scale generation jobs natively. 
+
+Perfectly engineered for **Agentic workflows** — enabling tools like OpenClaw, Claude, and Codex to autonomously generate JSON-driven movies from scratch.
+
+---
+
+## 🚀 Installation
+
+Install globally via npm:
+
+```bash
+npm install -g veogent
+```
+
+## 🔐 Quick Start (Authentication)
+
+Veogent CLI utilizes a secure, browser-based SSO flow via Firebase. 
+
+1. Run the login command:
+   ```bash
+   veogent login
+   ```
+2. The CLI will automatically open your default browser to `https://veogent.com/cli-auth`.
+3. Sign in via your account. The API access token will be silently transmitted back to your local terminal.
+4. Verify your session:
+   ```bash
+   veogent status
+   ```
+
+---
+
+## 🛠️ Key Capabilities
+
+All responses are provided in strict, pretty-printed **JSON** format to easily pipe `veogent` into `jq` or be parsed natively by AI Agents.
+
+### 📁 Project Management
+```bash
+# List all your active projects
+veogent projects
+
+# View available Image Material styles (e.g., CINEMATIC, PIXAR_3D)
+veogent image-materials
+
+# Create a brand new AI Story Project using your prompt
+veogent create-project -n "Cyberpunk T-Rex" -k "T-rex, Neon, Sci-fi" -d "A massive T-rex walking inside Tokyo" -l "English" -m "CINEMATIC" -c 5
+```
+
+### 📖 Storyboard, Chapters & Scenes
+```bash
+# Get all chapters within a project ID
+veogent chapters <projectId>
+
+# View characters cast for the project
+veogent characters <projectId>
+
+# Create scenes automatically using AI-generated narrative scripts
+veogent create-scene -p <projectId> -c <chapterId> --flowkey -C "The T-Rex looks up at the sky." "A meteor shower begins."
+```
+
+### 🖌️ Directing & Editing (AI Prompt adjustments)
+```bash
+# Edit an existing image prompt for a scene.
+# Note: Use camera direction verbs like "Wide shot," "Tilt up," or "Close-up."
+veogent edit-scene -p <proj> -c <chap> -s <scene> -u "Low angle shot of the T-Rex, dramatic lighting."
+
+# Apply a direct image in-paint edit to a specific character model
+veogent edit-character -p <proj> -c "drelenavance" -u "change outfit to dark leather jacket" -e
+```
+
+### 🎬 Media Generation (Gen Models)
+Queue generation jobs directly from the terminal. 
+*Note: VEOGENT uses strict validation depending on the request type.*
+
+```bash
+# Generate Image (Supports: imagen4, imagen3.5)
+veogent request -t "GENERATE_IMAGES" -p <proj> -c <chap> -s <scene> -i "imagen4"
+
+# Generate Video (Supports: veo_3_1_fast, veo_3_1_fast_r2v)
+veogent request -t "GENERATE_VIDEO" -p <proj> -c <chap> -s <scene> -v "veo_3_1_fast_r2v" -S "normal"
+
+# Generate Scene Video from existing Frame 0 (Requires orientation)
+veogent request -t "CREATE_SCENE_VIDEO" -p <proj> -c <chap> -s <scene> -o "HORIZONTAL"
+```
+
+---
+
+## 🤖 For AI Agents
+
+Veogent CLI comes with a built-in guide optimized for LLM/Coding Agents context processing. Just run:
+
+```bash
+veogent skill
+```
+This prints out a comprehensive Markdown `SKILL.md` cheat sheet defining our exact DTO validations, model enumerations, logic pipelines, and required variables for orchestrating complete projects without hitting `400 Bad Request`.
+
+---
+
+## 📜 License
+MIT License. Crafted with ❤️ by Pym & Tuan Nguyen.

package/api.js

@@ -0,0 +1,37 @@
+import axios from 'axios';
+import { getToken } from './config.js';
+
+// Define the environment variables
+const API_URL = process.env.VGEN_API_URL || 'https://api.veogent.com';
+
+// API instance helper
+export const api = axios.create({
+    baseURL: API_URL,
+});
+
+// Interceptor to inject bearer token before every request
+api.interceptors.request.use((config) => {
+    const token = getToken();
+    if (token) {
+        config.headers.Authorization = `Bearer ${token}`;
+    }
+    return config;
+}, (error) => {
+    return Promise.reject(error);
+});
+
+// Interceptor to handle specific errors generically
+api.interceptors.response.use(
+    (response) => {
+        // Return only the response data payload
+        return response.data;
+    },
+    (error) => {
+        if (error.response && error.response.status === 401) {
+            console.error('\n❌ Unauthorized! Your token might be expired. Please run `veogent login` again.');
+        } else {
+            console.error(`\n❌ Error: ${error.response?.data?.message || error.message}`);
+        }
+        process.exit(1);
+    }
+);

package/auth.js

@@ -0,0 +1,77 @@
+import express from 'express';
+import cors from 'cors';
+import open from 'open';
+import crypto from 'crypto';
+
+export class WebAuthFlow {
+    constructor(port = 7890) {
+        this.port = port;
+        this.app = express();
+        this.server = null;
+        // Generate a random token to verify the callback matches our local terminal
+        this.cliToken = crypto.randomBytes(32).toString('hex');
+    }
+
+    start() {
+        return new Promise((resolve, reject) => {
+            this.app.use(cors());
+            this.app.use(express.json());
+
+            // Callback endpoint hit by the Next.js frontend
+            this.app.post('/callback', (req, res) => {
+                const { uid, idToken, cliToken } = req.body;
+
+                // Basic CSRF/validation check
+                if (cliToken !== this.cliToken) {
+                    res.status(403).json({ error: 'Mismatched CLI Token' });
+                    return;
+                }
+
+                if (!uid || !idToken) {
+                    res.status(400).json({ error: 'Missing UID or Token' });
+                    return;
+                }
+
+                // Send success immediately so the browser UI updates to "Success" quickly
+                res.status(200).json({ status: 'success' });
+                
+                // Close the server and return credentials to the CLI
+                setTimeout(() => {
+                    this.stop();
+                    resolve({ uid, accessToken: idToken });
+                }, 1000);
+            });
+
+            this.server = this.app.listen(this.port, () => {
+                // Open the default browser to the web app's authorization page (en is default)
+                const frontendUrl = process.env.VGEN_WEB_URL || 'https://veogent.com';
+                const authUrl = `${frontendUrl}/cli-auth?port=${this.port}&token=${this.cliToken}`;
+                
+                console.log('🔄 Opening browser for authentication...');
+                console.log(`\nIf your browser doesn't open automatically, click this link:\n=> ${authUrl}\n`);
+                
+                open(authUrl).catch(() => {
+                    console.log('⚠️ Could not open browser automatically.');
+                });
+            }).on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    console.error(`\n❌ Error: Port ${this.port} is already in use.`);
+                    reject(err);
+                }
+            });
+            
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                this.stop();
+                reject(new Error('Authentication timeout.'));
+            }, 5 * 60 * 1000);
+        });
+    }
+
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+}

package/config.js

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+
+// Define the path for the config directory and file
+const configDir = path.join(process.env.HOME || process.env.USERPROFILE, '.vgen-cli');
+const configPath = path.join(configDir, 'config.json');
+
+// Get the current configuration
+export const getConfig = () => {
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    const data = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(data);
+};
+
+// Get the stored token
+export const getToken = () => {
+    const config = getConfig();
+    return config.token || null;
+};
+
+// Set and save the configuration
+export const setConfig = (newConfig) => {
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    const config = { ...getConfig(), ...newConfig };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+};
+
+// Clear the configuration
+export const clearConfig = () => {
+    if (fs.existsSync(configPath)) {
+        fs.unlinkSync(configPath);
+    }
+};

package/index.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { api } from './api.js';
+import { setConfig, clearConfig, getToken } from './config.js';
+
+const program = new Command();
+
+program
+    .name('veogent')
+    .description('CLI to interact with the VEOGENT API')
+    .version('1.0.0');
+
+import { WebAuthFlow } from './auth.js';
+
+// Login
+program
+    .command('login')
+    .description('Login to obtain access token via Web Browser')
+    .action(async () => {
+        try {
+            console.log('\n--- 🌐 VEOGENT CLI Web Authentication ---');
+            console.log('We will now open your default web browser to authorize VEOGENT CLI.\n');
+            
+            // Start local web server to catch the callback from the Next.js app
+            const authFlow = new WebAuthFlow(7890); // default port
+            const authResult = await authFlow.start();
+
+            // Perform backend sign-in using the payload received from the browser
+            console.log('\n🔄 Credentials received! Saving API Access Token...');
+            const response = { data: { access_token: authResult.accessToken, email: authResult.uid, name: 'CLI User' } }; // JWT mapped 
+
+            if (response?.data?.access_token) {
+                setConfig({ token: response.data.access_token, user: response.data });
+                console.log(`✅ Successfully logged in as: ${response.data.email || response.data.name}`);
+                console.log(`You can now use all VEOGENT CLI commands!`);
+            } else {
+                console.error('❌ Failed to retrieve access token from VEOGENT Backend.');
+            }
+        } catch (error) {
+            console.error('\n❌ Login process failed or was canceled.', error.message);
+        }
+    });
+
+// Logout
+program
+    .command('logout')
+    .description('Clear saved credentials')
+    .action(() => {
+        clearConfig();
+        console.log('✅ Logged out successfully.');
+    });
+
+// Status
+program
+    .command('status')
+    .description('Show current authenticated user')
+    .action(async () => {
+        const token = getToken();
+        if (!token) {
+            console.log(JSON.stringify({ error: 'Not logged in' }));
+            return;
+        }
+
+        try {
+            const response = await api.get('/app/flow-key');
+            console.log(JSON.stringify({ authenticated: true, flowKey: response.data?.flowKey || null }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ error: 'Error verifying token' }));
+        }
+    });
+
+// --- Prompts & Materials ---
+program
+    .command('image-materials')
+    .description('Get all available Image Material styles')
+    .action(async () => {
+        try {
+            const data = await api.get('/app/project/image-materials');
+            console.log(JSON.stringify(data.data || data, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+program
+    .command('custom-prompts')
+    .description('Get all custom prompt templates / story directives')
+    .action(async () => {
+        try {
+            const data = await api.get('/app/custom-prompts');
+            console.log(JSON.stringify(data.data || data, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+program
+    .command('projects')
+    .description('List your available projects')
+    .action(async () => {
+        try {
+            const data = await api.get('/app/projects');
+            console.log(JSON.stringify(data, null, 2));
+        } catch (error) {}
+    });
+
+program
+    .command('project <id>')
+    .description('Get details for a specific project')
+    .action(async (id) => {
+        try {
+            const data = await api.get(`/app/project/${id}`);
+            console.log(JSON.stringify(data.data, null, 2));
+        } catch (error) {}
+    });
+
+program
+    .command('create-project-description')
+    .description('Generate AI description for a new project based on keywords')
+    .requiredOption('-k, --keyword <keyword>', 'Keywords for the project')
+    .requiredOption('-l, --lang <lang>', 'Story language')
+    .requiredOption('-p, --promptId <promptId>', 'Custom Prompt ID from custom-prompts')
+    .action(async (options) => {
+        try {
+            const payload = {
+                keywords: options.keyword,
+                language: options.lang,
+                customPromptId: options.promptId,
+                objects: []
+            };
+            const data = await api.post('/app/description', payload);
+            console.log(JSON.stringify({ status: "success", descriptionData: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.response?.data?.message || error.message }));
+        }
+    });
+
+program
+    .command('create-project')
+    .description('Create a new project')
+    .requiredOption('-n, --name <name>', 'Project name')
+    .requiredOption('-k, --keyword <keyword>', 'Keyword')
+    .requiredOption('-d, --desc <desc>', 'Description')
+    .requiredOption('-l, --lang <lang>', 'Story language')
+    .requiredOption('-s, --sound', 'Sound effects (true/false)', true)
+    .requiredOption('-m, --material <material>', 'Image material')
+    .requiredOption('-c, --chapters <count>', 'Number of chapters', 1)
+    .option('-C, --customPromptId <customPromptId>', 'Custom Prompt ID')
+    .action(async (options) => {
+        try {
+            const payload = {
+                projectName: options.name,
+                keyword: options.keyword,
+                description: options.desc,
+                storyLanguage: options.lang,
+                soundEffects: options.sound === 'true' || options.sound === true,
+                imageMaterial: options.material,
+                numberChapters: parseInt(options.chapters),
+            };
+            if (options.customPromptId) payload.customPromptId = options.customPromptId;
+
+            const data = await api.post('/app/project', payload);
+            console.log(JSON.stringify({ status: "success", project: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+// --- Chapters ---
+program
+    .command('chapters <projectId>')
+    .description('Get all chapters for a project')
+    .action(async (projectId) => {
+        try {
+            const data = await api.get(`/app/chapters/${projectId}`);
+            console.log(JSON.stringify(data, null, 2));
+        } catch (error) {}
+    });
+
+program
+    .command('create-chapter-content')
+    .description('Generate content for a specific chapter')
+    .requiredOption('-p, --project <project>', 'Project ID')
+    .requiredOption('-c, --chapter <chapter>', 'Chapter ID')
+    .requiredOption('-s, --scenes <count>', 'Number of scenes', 1)
+    .action(async (options) => {
+        try {
+            const payload = {
+                project: options.project,
+                chapter: options.chapter,
+                numberScene: parseInt(options.scenes),
+            };
+            const data = await api.post('/app/chapter/content', payload);
+            console.log(JSON.stringify({ status: "success", chapterContent: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+
+// --- Characters ---
+program
+    .command('characters <projectId>')
+    .description('Get all characters for a specific project')
+    .action(async (projectId) => {
+        try {
+            const data = await api.get(`/app/characters/${projectId}`);
+            console.log(JSON.stringify(data.data || data, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+program
+    .command('edit-character')
+    .description('Update a character\'s description or edit their generated image directly via AI prompt')
+    .requiredOption('-p, --project <project>', 'Project ID')
+    .requiredOption('-c, --character <character>', 'Character ID (e.g., drelenavance)')
+    .requiredOption('-u, --userprompt <userprompt>', 'User instruction to modify the character')
+    .option('-e, --editimage', 'Enable direct Image Editing Mode (true). Default is Regenerate Profile Mode (false)', false)
+    .option('--flowkey', 'Enable useFlowKey to sync context via FireBase', true)
+    .action(async (options) => {
+        try {
+            const payload = {
+                userPrompt: options.userprompt,
+                useFlowKey: options.flowkey === true || options.flowkey === 'true',
+                editImageMode: options.editimage === true,
+            };
+            const data = await api.post(`/app/character/${options.project}/${options.character}/update-by-prompt`, payload);
+            console.log(JSON.stringify({ status: "success", character: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.response?.data?.message || error.message }));
+        }
+    });
+program
+    .command('create-scene')
+    .description('Create a new scene from text content')
+    .requiredOption('-p, --project <project>', 'Project ID')
+    .requiredOption('-c, --chapter <chapter>', 'Chapter ID')
+    .requiredOption('-C, --content <content...>', 'Array of scene text scripts')
+    .option('--flowkey', 'Enable useFlowKey to sync context via FireBase', false)
+    .action(async (options) => {
+        try {
+            const payload = {
+                project: options.project,
+                chapter: options.chapter,
+                chapterContent: options.content,
+                useFlowKey: options.flowkey === true,
+            };
+            const data = await api.post('/app/scene', payload);
+            console.log(JSON.stringify({ status: "success", scene: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+program
+    .command('edit-scene')
+    .description('Edit an existing scene (image prompt) via AI assistance')
+    .requiredOption('-p, --project <project>', 'Project ID')
+    .requiredOption('-c, --chapter <chapter>', 'Chapter ID')
+    .requiredOption('-s, --scene <scene>', 'Scene ID')
+    .requiredOption('-u, --userprompt <userprompt>', 'User narrative prompt to modify the scene')
+    .option('--no-regenerate', 'Tells backend to NOT automatically trigger regenerating the image')
+    .option('-R, --request <request>', 'Target a specific past Request ID to edit its output')
+    .action(async (options) => {
+        try {
+            const payload = {
+                userPrompt: options.userprompt,
+                regenerateImage: options.regenerate !== false, 
+            };
+
+            if (options.request) {
+                payload.requestId = options.request;
+            }
+
+            const data = await api.patch(`/app/scene/script-segment/${options.project}/${options.chapter}/${options.scene}`, payload);
+            console.log(JSON.stringify({ status: "success", scene: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.response?.data?.message || error.message }));
+        }
+    });
+
+// --- Execution Request (Generate Image / Video) ---
+program
+    .command('request')
+    .description('Create a job request (GENERATE_IMAGES, GENERATE_VIDEO, CREATE_SCENE_VIDEO)')
+    .requiredOption('-t, --type <type>', 'Request type (e.g., GENERATE_IMAGES, GENERATE_VIDEO)')
+    .requiredOption('-p, --project <project>', 'Project ID')
+    .requiredOption('-c, --chapter <chapter>', 'Chapter ID')
+    .requiredOption('-s, --scene <scene>', 'Scene ID')
+    .option('-o, --orientation <orientation>', 'Request orientation (HORIZONTAL, VERTICAL)', '')
+    .option('-i, --imagemodel <imagemodel>', 'Image Model (imagen4, imagen3.5)', 'imagen4')
+    .option('-v, --videomodel <videomodel>', 'Video Model (veo_3_1_fast, veo_3_1_fast_r2v)', 'veo_3_1_fast_r2v')
+    .option('-S, --speed <speed>', 'Video Speed (normal, timelapse, slowmotion)', 'normal')
+    .action(async (options) => {
+        try {
+            const payload = {
+                type: options.type,
+                project: options.project,
+                chapter: options.chapter,
+                scene: options.scene,
+            };
+
+            // Conditionally add fields based on strict DTO validators
+            if (['CREATE_SCENE_VIDEO', 'CREATE_CHAPTER_VIDEO', 'VIDEO_UPSCALE'].includes(options.type)) {
+                payload.orientation = options.orientation || 'HORIZONTAL'; // Provide fallback
+            }
+            if (options.type === 'GENERATE_IMAGES') {
+                payload.imageModel = options.imagemodel;
+            }
+            if (options.type === 'GENERATE_VIDEO') {
+                payload.model = options.videomodel;
+                payload.videoSpeedMode = options.speed;
+                payload.useFlowKey = false;
+            }
+
+            const data = await api.post('/app/request', payload);
+            console.log(JSON.stringify({ status: "success", request: data.data || data }, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+program
+    .command('requests')
+    .description('Get all generation requests/jobs status for the current user')
+    .action(async () => {
+        try {
+            const data = await api.get('/app/requests');
+            console.log(JSON.stringify(data.data || data, null, 2));
+        } catch (error) {
+            console.log(JSON.stringify({ status: "error", message: error.message }));
+        }
+    });
+
+// --- System ---
+program
+    .command('skill')
+    .description('Print the native Agent SKILL.md guide for VEOGENT CLI')
+    .action(() => {
+        const skillContent = `# VEOGENT CLI Agent Skill
+
+The \`veogent\` command-line interface interacts with the VEOGENT API for managing movie/story projects, chapters, scenes, and media generation requests (images, videos). 
+This CLI is designed with AI agents in mind: all data outputs are in raw JSON format for easy parsing and chaining.
+
+## 🛠 Authentication 
+Agents **CANNOT** authenticate automatically because \`veogent login\` opens a local browser for Google Firebase OAuth.
+*   **Check Auth:** \`veogent status\`
+*   **Action:** If status returns \`{"error": "Not logged in"}\`, instruct the user to run \`veogent login\` on their desktop terminal manually. Wait for them to confirm success.
+
+## 📁 Projects & Assets
+*   **List Image Materials:** \`veogent image-materials\` (e.g., \`CINEMATIC\`, \`PIXAR_3D\`)
+*   **List Custom Prompts:** \`veogent custom-prompts\`
+*   **List Projects:** \`veogent projects\` 
+    *   *Note: IDs are Firebase Document Strings (e.g., \`APQF6Ay0kLeXLhpctTdD\`), not simple integers. Always use the field \`"id"\` from the JSON response array.*
+*   **Get Project Details:** \`veogent project <projectId>\`
+*   **Create Project:** \`veogent create-project -n "Project Name" -k "Scifi" -d "Description" -l "English" -m "Anime style" -c 1\`
+
+## 📖 Chapters & Scenes
+*   **List Chapters for a Project:** \`veogent chapters <projectId>\`
+*   **Create Chapter Content:** \`veogent create-chapter-content -p <projectId> -c <chapterId> -s 5\` (Generates text/story content for 5 scenes)
+*   **Create Scene:** \`veogent create-scene -p <projectId> -c <chapterId> -C <sceneId1> <sceneId2>\`
+
+## 🎬 Generation Requests
+To initiate generation jobs, use \`veogent request\`. 
+**CRITICAL VALIDATION RULES (Strict DTO):** 
+Do not pass unsupported flags for a specific type, or the server will return a \`400 Bad Request\` or \`Validation Error\`.
+
+1.  **Generate Images** (\`GENERATE_IMAGES\`):
+    *   **Required Options:** \`-t GENERATE_IMAGES\`, \`-p <proj>\`, \`-c <chap>\`, \`-s <scene>\`, \`-i <imagemodel>\`
+    *   **Allowed Models:** \`imagen4\`, \`imagen3.5\`
+    *   **Prohibited:** Do NOT pass \`-o\` (orientation) or \`-v\` (videomodel) or \`-S\` (speed).
+    *   \`veogent request -t "GENERATE_IMAGES" -p "projID" -c "chapID" -s "sceneID" -i "imagen4"\`
+
+2.  **Generate Video** (\`GENERATE_VIDEO\`):
+    *   **Required Options:** \`-t GENERATE_VIDEO\`, \`-p <proj>\`, \`-c <chap>\`, \`-s <scene>\`, \`-v <videomodel>\`, \`-S <speed>\`
+    *   **Allowed Models:** \`veo_3_1_fast\`, \`veo_3_1_fast_r2v\`
+    *   **Allowed Speeds:** \`normal\`, \`timelapse\`, \`slowmotion\`
+    *   \`veogent request -t "GENERATE_VIDEO" -p "projID" -c "chapID" -s "sceneID" -v "veo_3_1_fast_r2v" -S "normal"\`
+
+3.  **Create Scene Video / Chapter Video** (\`CREATE_SCENE_VIDEO\` / \`CREATE_CHAPTER_VIDEO\` / \`VIDEO_UPSCALE\`):
+    *   **Required Options:** \`-t <type>\`, \`-p <proj>\`, \`-c <chap>\`, \`-s <scene>\`, \`-o <orientation>\`
+    *   **Allowed Orientations:** \`HORIZONTAL\`, \`VERTICAL\`
+    *   **Prohibited:** Do NOT pass \`-i\` (image model) or \`-v\` (video model).
+    *   \`veogent request -t "CREATE_SCENE_VIDEO" -p "projID" -c "chapID" -s "sceneID" -o "HORIZONTAL"\`
+
+## 🖌️ Character Editing
+Characters generated within a project can be updated or re-sketched via text prompts using \`veogent edit-character\`.
+*   **List all Characters in a Project:** 
+    *   \`veogent characters <projectId>\`
+*   **Regenerate Character Profile:** (Updates description/traits and generates a new portrait base)
+    *   \`veogent edit-character -p <proj> -c "drelenavance" -u "change outfit to lab coat"\`
+*   **Direct Image Edit Mode:** (Applies changes directly to the existing generated portrait)
+    *   \`veogent edit-character -p <proj> -c "drelenavance" -u "change shoe to black" -e\`
+
+## 🖌️ Scene Editing
+If a generated image prompt needs adjustment by the AI, use \`veogent edit-scene\` to hit the \`updateScriptSegment\` workflow:
+*   **Context:** Note that you are editing the Image Prompt for **Frame 0 (the starting image)** used for video generation. 
+*   **Prompting Guide:** Beside the main visual description, you CAN include minor action descriptions (e.g., "bus speeding over cliff", "smoke rising"). You SHOULD heavily leverage Camera Angles and Camera Movements to steer the frame composition:
+    *   **Shot Types:** Close-up (Cận cảnh), Wide shot (Toàn cảnh), Medium shot (Trung cảnh), Extreme close-up (Cận mặt), Long shot (Tầm trung xa).
+    *   **Angles:** High angle (Góc cao), Low angle (Góc thấp), Bird-eye (Góc chim), Eye-level (Góc ngang mắt), Over-the-shoulder, POV.
+    *   **Camera Tracking:** Pan left (←), Pan right (→), Tilt up (↑), Tilt down (↓), Zoom in (+), Zoom out (-).
+*   **Modify Image Prompt (Default creates auto-regen):**
+    *   \`veogent edit-scene -p <proj> -c <chap> -s <scene> -u "Low angle shot of a yellow school bus speeding over a cliff, wide angle, dramatic lighting. Camera tilts down."\`
+*   **Modify Image Prompt (Cancel Auto-Regen):**
+    *   \`veogent edit-scene -p <proj> -c <chap> -s <scene> -u "child seat behind Paulo" --no-regenerate\`
+*   **Edit a specific past generated image:** Pass the previous generated \`requestId\` using \`-R\`.
+    *   \`veogent edit-scene -p <proj> -c <chap> -s <scene> -u "make the car red" -R <requestId>\`
+
+*   **List All Generation Requests/Jobs Status:** \`veogent requests\` 
+
+## 💡 Best Practices for AI Agents
+1. **Data Chaining Workflow:** Always use the ID strings from \`veogent projects\` -> pass to \`veogent chapters\` -> extract \`sceneId\` -> pass to \`veogent request <...args>\`.
+2. **Error Handling:** The CLI returns JSON like \`{"status": "error", "message": "..."}\`. Check this before proceeding with the next logic block.
+3. If an API request returns \`400 Bad Request\`, review your flags. You might be sending forbidden options for the requested DTO \`RequestType\`.`;
+        console.log(skillContent);
+    });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "veogent",
+  "version": "1.0.0",
+  "description": "The official CLI to interact with the VEOGENT API - AI Video and Image generation platform",
+  "main": "index.js",
+  "bin": {
+    "veogent": "./index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "veogent",
+    "cli",
+    "ai",
+    "video-generation",
+    "image-generation",
+    "sora",
+    "veo"
+  ],
+  "author": "Pym & Tuan Nguyen",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "commander": "^14.0.3",
+    "cors": "^2.8.6",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "form-data": "^4.0.5",
+    "inquirer": "^13.3.0",
+    "open": "^11.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://veogent.com"
+  }
+}