lua-cli 3.1.0 → 3.2.0-alpha.1

package/dist/types/skill.js

@@ -3,16 +3,11 @@
  * Core types and classes for building Lua AI skills
  */
 import { assertValidToolName } from "./tool-validation.js";
-import fs from "fs";
-import path from "path";
-import yaml from "js-yaml";
 /**
  * Safe environment variable access function.
  * Gets injected at runtime with skill-specific environment variables.
  *
- * Checks in order:
- * 1. Process environment variables (.env file)
- * 2. lua.skill.yaml configuration
+ * Checks process environment variables (.env file)
  *
  * @param key - The environment variable key to retrieve
  * @returns The environment variable value or undefined if not found
@@ -24,32 +19,8 @@ import yaml from "js-yaml";
  * ```
  */
 export const env = (key) => {
-    // Try to load environment variables from lua.skill.yaml
-    try {
-        // Check process.env first (.env file)
-        if (process.env[key]) {
-            return process.env[key];
-        }
-        // Look for lua.skill.yaml in current directory and parent directories
-        let currentDir = process.cwd();
-        let yamlPath = null;
-        while (currentDir !== path.dirname(currentDir)) {
-            const potentialPath = path.join(currentDir, 'lua.skill.yaml');
-            if (fs.existsSync(potentialPath)) {
-                yamlPath = potentialPath;
-                break;
-            }
-            currentDir = path.dirname(currentDir);
-        }
-        if (yamlPath) {
-            const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-            const config = yaml.load(yamlContent);
-            return config?.skill?.env?.[key];
-        }
-    }
-    catch (error) {
-        // If we can't load the YAML, fall back to undefined
-        console.warn(`Warning: Could not load environment variables from lua.skill.yaml: ${error}`);
+    if (process.env[key]) {
+        return process.env[key];
     }
     return undefined;
 };

package/dist/utils/agent-code-utils.d.ts

@@ -0,0 +1,24 @@
+export interface AgentCodeData {
+    name: string;
+    persona: string;
+}
+/**
+ * Load agent data (name, persona) from code (LuaAgent definition).
+ */
+export declare function loadAgentFromCode(): AgentCodeData;
+/**
+ * Save agent data (name and/or persona) into code (LuaAgent definition).
+ */
+export declare function saveAgentToCode(data: Partial<AgentCodeData>): boolean;
+/**
+ * Updates the LuaAgent configuration in the index.ts file.
+ *
+ * @param projectDir - Project directory containing src/index.ts
+ * @param data - Agent data to update (name and/or persona)
+ */
+export declare function updateLuaAgentInCode(projectDir: string, data: Partial<AgentCodeData>): void;
+export declare const loadNameFromCode: () => string;
+export declare const loadPersonaFromCode: () => string;
+export declare const saveNameToCode: (name: string) => boolean;
+export declare const savePersonaToCode: (persona: string) => boolean;
+export declare function updateLuaAgentInIndexFile(projectDir: string, agentName?: string, persona?: string): void;

package/dist/utils/agent-code-utils.js

@@ -0,0 +1,96 @@
+import { Project, Node } from 'ts-morph';
+import path from 'path';
+import fs from 'fs';
+import { findIndexFile, extractLuaAgentMetadata } from './compile.js';
+/**
+ * Load agent data (name, persona) from code (LuaAgent definition).
+ */
+export function loadAgentFromCode() {
+    try {
+        const indexPath = findIndexFile();
+        const project = new Project({
+            skipAddingFilesFromTsConfig: true,
+        });
+        const indexFile = project.addSourceFileAtPath(indexPath);
+        const metadata = extractLuaAgentMetadata(indexFile);
+        return {
+            name: metadata?.name || '',
+            persona: metadata?.persona || '',
+        };
+    }
+    catch (error) {
+        console.warn('Warning: Could not load agent from code:', error);
+        return { name: '', persona: '' };
+    }
+}
+/**
+ * Save agent data (name and/or persona) into code (LuaAgent definition).
+ */
+export function saveAgentToCode(data) {
+    try {
+        updateLuaAgentInCode(process.cwd(), data);
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Error saving agent to code:', error);
+        return false;
+    }
+}
+/**
+ * Updates the LuaAgent configuration in the index.ts file.
+ *
+ * @param projectDir - Project directory containing src/index.ts
+ * @param data - Agent data to update (name and/or persona)
+ */
+export function updateLuaAgentInCode(projectDir, data) {
+    const indexPath = path.join(projectDir, 'src', 'index.ts');
+    if (!fs.existsSync(indexPath)) {
+        return;
+    }
+    try {
+        const project = new Project({ skipAddingFilesFromTsConfig: true });
+        const sourceFile = project.addSourceFileAtPath(indexPath);
+        sourceFile.forEachDescendant((node) => {
+            if (Node.isNewExpression(node) && node.getExpression().getText() === 'LuaAgent') {
+                const args = node.getArguments();
+                if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+                    const configObj = args[0];
+                    configObj.getProperties().forEach((prop) => {
+                        if (Node.isPropertyAssignment(prop)) {
+                            const propName = prop.getName();
+                            if (data.name !== undefined && propName === 'name') {
+                                const init = prop.getInitializer();
+                                if (init) {
+                                    init.replaceWithText(`'${data.name.replace(/'/g, "\\'")}'`);
+                                }
+                            }
+                            if (data.persona !== undefined && propName === 'persona') {
+                                const init = prop.getInitializer();
+                                if (init) {
+                                    const escaped = data.persona.replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+                                    init.replaceWithText(`\`${escaped}\``);
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        });
+        sourceFile.saveSync();
+    }
+    catch (error) {
+        console.warn('Warning: Could not update LuaAgent in index.ts');
+    }
+}
+// Legacy aliases for backward compatibility
+export const loadNameFromCode = () => loadAgentFromCode().name;
+export const loadPersonaFromCode = () => loadAgentFromCode().persona;
+export const saveNameToCode = (name) => saveAgentToCode({ name });
+export const savePersonaToCode = (persona) => saveAgentToCode({ persona });
+// Re-export for init-helpers.ts compatibility
+export function updateLuaAgentInIndexFile(projectDir, agentName, persona) {
+    updateLuaAgentInCode(projectDir, {
+        ...(agentName !== undefined && { name: agentName }),
+        ...(persona !== undefined && { persona })
+    });
+}

package/dist/utils/compile.js

@@ -520,16 +520,16 @@ export function extractLuaAgentMetadata(indexFile) {
                             const propName = prop.getName();
                             const value = prop.getInitializer();
                             if (propName === 'name' && value) {
-                                name = value.getText().replace(/['"]/g, '');
+                                // Use getLiteralValue for proper string extraction
+                                if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
+                                    name = value.getLiteralValue();
+                                }
                             }
                             else if (propName === 'persona' && value) {
-                                // Handle multi-line strings and template literals
-                                const personaText = value.getText();
-                                persona = personaText
-                                    .replace(/^['"`]/, '')
-                                    .replace(/['"`]$/, '')
-                                    .replace(/\\n/g, '\n')
-                                    .trim();
+                                // Use getLiteralValue to get actual string value (handles escapes correctly)
+                                if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
+                                    persona = value.getLiteralValue().trim();
+                                }
                             }
                             else if (propName === 'skills' && value && Node.isArrayLiteralExpression(value)) {
                                 // Extract skill references from the array

package/dist/utils/dev-server.js

@@ -7,7 +7,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { createServer } from 'http';
 import { WebSocketServer } from 'ws';
-import { readSkillConfig, updateSkillYamlPersona } from './files.js';
+import { readSkillConfig } from './files.js';
 import { executeTool, createBroadcastConsole, loadEnvironmentVariables } from './sandbox.js';
 import { getSandboxSkillId } from './sandbox-storage.js';
 import { sendChatMessage } from './dev-api.js';
@@ -17,6 +17,7 @@ import ProductApi from '../api/products.api.service.js';
 import BasketApi from '../api/basket.api.service.js';
 import OrderApi from '../api/order.api.service.js';
 import CustomDataApi from '../api/custom.data.api.service.js';
+import { loadPersonaFromCode, savePersonaToCode } from './agent-code-utils.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -200,8 +201,7 @@ function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deplo
  */
 function handleGetPersonaEndpoint(req, res) {
     try {
-        const config = readSkillConfig();
-        const persona = config?.agent?.persona || '';
+        const persona = loadPersonaFromCode();
         res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
             success: true,
@@ -224,7 +224,7 @@ function handlePostPersonaEndpoint(req, res) {
     req.on('end', async () => {
         try {
             const { persona } = JSON.parse(body);
-            updateSkillYamlPersona(persona);
+            savePersonaToCode(persona);
             res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 success: true,
@@ -520,6 +520,7 @@ function handleToolTestEndpoint(req, res, apiKey, agentId, wss) {
                 inputs,
                 apiKey,
                 agentId,
+                channel: 'dev',
                 customConsole
             });
             // Broadcast tool test completion

package/dist/utils/files.d.ts

@@ -6,11 +6,9 @@
  * @param includeExamples - Whether to include the examples/ directory (default: false)
  */
 export declare function copyTemplateFiles(templateDir: string, targetDir: string, includeExamples?: boolean): void;
-export declare function createSkillYaml(agentId: string, orgId: string, skillName?: string, skillId?: string, persona?: string): void;
 export declare function readSkillYaml(): any;
 export declare function readSkillConfig(): any;
 /**
  * Update only the agent information in an existing YAML file
  */
-export declare function updateYamlAgent(agentId: string, orgId: string, persona?: string): void;
-export declare function updateSkillYamlPersona(persona: string): void;
+export declare function updateYamlAgent(agentId: string, orgId: string): void;

package/dist/utils/files.js

@@ -64,18 +64,6 @@ function updatePackageJson(srcPath, destPath) {
     // Write the updated package.json
     fs.writeFileSync(destPath, JSON.stringify(templatePackageJson, null, 2) + '\n');
 }
-export function createSkillYaml(agentId, orgId, skillName, skillId, persona) {
-    // Handle multiline strings properly for YAML
-    const personaSection = persona ? `  persona: |\n${persona.split('\n').map(line => `    ${line}`).join('\n')}\n` : '';
-    const yamlContent = `agent:
-  agentId: "${agentId}"
-  orgId: "${orgId}"
-${personaSection}
-skills:
-  # Skills will be auto-generated during compilation
-`;
-    fs.writeFileSync("lua.skill.yaml", yamlContent);
-}
 export function readSkillYaml() {
     const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
     if (!fs.existsSync(yamlPath)) {
@@ -91,7 +79,7 @@ export function readSkillConfig() {
 /**
  * Update only the agent information in an existing YAML file
  */
-export function updateYamlAgent(agentId, orgId, persona) {
+export function updateYamlAgent(agentId, orgId) {
     const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
     if (!fs.existsSync(yamlPath)) {
         throw new Error('lua.skill.yaml not found');
@@ -101,9 +89,6 @@ export function updateYamlAgent(agentId, orgId, persona) {
     config.agent = config.agent || {};
     config.agent.agentId = agentId;
     config.agent.orgId = orgId;
-    if (persona) {
-        config.agent.persona = persona;
-    }
     // Write back to file
     const yamlContent = dump(config, {
         indent: 2,
@@ -112,26 +97,3 @@ export function updateYamlAgent(agentId, orgId, persona) {
     });
     fs.writeFileSync(yamlPath, yamlContent);
 }
-export function updateSkillYamlPersona(persona) {
-    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
-    if (!fs.existsSync(yamlPath)) {
-        console.error('❌ No lua.skill.yaml found. Please run this command from a skill directory.');
-        return;
-    }
-    const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-    const data = load(yamlContent);
-    // Update persona
-    if (!data.agent) {
-        data.agent = {};
-    }
-    data.agent.persona = persona;
-    // Use yaml.dump to properly handle both old and new formats
-    const updatedYamlContent = dump(data, {
-        indent: 2,
-        lineWidth: -1,
-        noRefs: true,
-        quotingType: '"',
-        forceQuotes: false
-    });
-    fs.writeFileSync(yamlPath, updatedYamlContent);
-}

package/dist/utils/init-helpers.d.ts

@@ -40,11 +40,3 @@ export declare function calculatePromptLines(baseCount: number, additionalLines:
  * @param lineCount - Number of lines to clear
  */
 export declare function clearLinesIfNeeded(lineCount: number): void;
-/**
- * Updates the LuaAgent configuration in the template's index.ts file
- *
- * @param projectDir - Project directory containing src/index.ts
- * @param agentName - Name of the agent
- * @param persona - Agent persona
- */
-export declare function updateLuaAgentInIndexFile(projectDir: string, agentName?: string, persona?: string): void;

package/dist/utils/init-helpers.js

@@ -4,10 +4,10 @@
  */
 import { fileURLToPath } from "url";
 import path from "path";
-import fs from "fs";
-import { copyTemplateFiles, createSkillYaml } from "./files.js";
+import { copyTemplateFiles, updateYamlAgent } from "./files.js";
 import { clearPromptLines, writeProgress } from "./cli.js";
 import { execSync } from 'child_process';
+import { updateLuaAgentInIndexFile } from './agent-code-utils.js';
 /**
  * Gets the template directory path.
  *
@@ -32,7 +32,8 @@ export function initializeProject(agentId, orgId, persona, agentName, withExampl
     const templateDir = getTemplateDir();
     const currentDir = process.cwd();
     copyTemplateFiles(templateDir, currentDir, withExamples);
-    createSkillYaml(agentId, orgId, undefined, undefined, persona);
+    // Update the templated lua.skill.yaml with actual agent/org IDs
+    updateYamlAgent(agentId, orgId);
     // Update LuaAgent in index.ts with agent configuration
     updateLuaAgentInIndexFile(currentDir, agentName, persona);
     writeProgress("✅ Created lua.skill.yaml");
@@ -79,37 +80,3 @@ export function clearLinesIfNeeded(lineCount) {
         clearPromptLines(lineCount);
     }
 }
-/**
- * Updates the LuaAgent configuration in the template's index.ts file
- *
- * @param projectDir - Project directory containing src/index.ts
- * @param agentName - Name of the agent
- * @param persona - Agent persona
- */
-export function updateLuaAgentInIndexFile(projectDir, agentName, persona) {
-    const indexPath = path.join(projectDir, 'src', 'index.ts');
-    if (!fs.existsSync(indexPath)) {
-        // If no index.ts, skip (might be an old template structure)
-        return;
-    }
-    try {
-        let content = fs.readFileSync(indexPath, 'utf8');
-        // Check if LuaAgent exists in the file
-        if (!content.includes('new LuaAgent(')) {
-            return; // No LuaAgent to update
-        }
-        // Update agent name
-        if (agentName) {
-            content = content.replace(/name:\s*['"][^'"]*['"]/, `name: '${agentName.replace(/'/g, "\\'")}'`);
-        }
-        // Update persona
-        if (persona) {
-            content = content.replace(/(persona:\s*['"`])[\s\S]*?(['"`])/, `$1${persona.replace(/'/g, "\\'").replace(/`/g, '\\`')}$2`);
-        }
-        fs.writeFileSync(indexPath, content);
-    }
-    catch (error) {
-        // Silently fail - not critical
-        console.warn('Warning: Could not update LuaAgent in index.ts');
-    }
-}

package/dist/utils/job-management.js

@@ -134,8 +134,7 @@ async function updateYamlWithJobs(config) {
     const cleanedJobs = jobs.map(job => ({
         name: job.name || '',
         version: job.version || SKILL_DEFAULTS.VERSION,
-        jobId: job.jobId || '',
-        schedule: job.schedule || { type: 'cron', expression: '0 0 * * *' }
+        jobId: job.jobId || ''
     }));
     // Update config with cleaned jobs array
     const updatedConfig = {

package/dist/utils/sandbox.d.ts

@@ -1,6 +1,8 @@
+import { Channel } from "../interfaces/lua.js";
 export interface SandboxOptions {
     apiKey: string;
     agentId: string;
+    channel?: Channel;
     customConsole?: any;
     broadcastLog?: (logData: any) => void;
 }
@@ -21,19 +23,18 @@ export interface ExecuteJobOptions extends SandboxOptions {
 export interface ExecutePreProcessorOptions extends SandboxOptions {
     processorCode: string;
     messages: any[];
-    channel: string;
+    channel: Channel;
 }
 export interface ExecutePostProcessorOptions extends SandboxOptions {
     processorCode: string;
     message: string;
     response: string;
-    channel: string;
+    channel: Channel;
 }
 /**
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
  * 2. .env file (medium priority)
- * 3. lua.skill.yaml env section (highest priority)
  */
 export declare function loadEnvironmentVariables(): Record<string, string>;
 /**

package/dist/utils/sandbox.js

@@ -2,7 +2,6 @@ import { createRequire } from "module";
 import vm from "vm";
 import path from "path";
 import fs from "fs";
-import { readSkillConfig } from "./files.js";
 import UserDataApiService from "../api/user.data.api.service.js";
 import { BASE_URLS } from "../config/constants.js";
 import ProductApiService from "../api/products.api.service.js";
@@ -20,7 +19,6 @@ import { compressCode } from "./compile.js";
  * Loads environment variables from multiple sources in priority order:
  * 1. process.env (lowest priority)
  * 2. .env file (medium priority)
- * 3. lua.skill.yaml env section (highest priority)
  */
 export function loadEnvironmentVariables() {
     const envVars = {};
@@ -51,13 +49,6 @@ export function loadEnvironmentVariables() {
             console.warn('Warning: Could not read .env file:', error);
         }
     }
-    // 3. Override with YAML config values (highest priority)
-    const config = readSkillConfig();
-    if (config?.skill?.env) {
-        for (const [key, value] of Object.entries(config.skill.env)) {
-            envVars[key] = value;
-        }
-    }
     return envVars;
 }
 /**
@@ -226,6 +217,11 @@ export function createSandbox(options) {
         null: null,
         Infinity: Infinity,
         NaN: NaN,
+        Lua: {
+            request: {
+                channel: options.channel ?? 'unknown',
+            },
+        },
         User: userService,
         Products: productService,
         Data: dataService,

package/dist/utils/sync-helpers.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Sync Helpers
+ * Utilities for detecting drift between server state and local code
+ */
+export interface PersonaDrift {
+    hasDrift: boolean;
+    serverPersona: string | null;
+    localPersona: string;
+    serverVersion?: number;
+}
+export interface NameDrift {
+    hasDrift: boolean;
+    serverName: string | null;
+    localName: string;
+}
+/**
+ * Fetch the latest published persona version from the server.
+ * Returns null if no persona is published or on error.
+ *
+ * Note: This returns the most recently published version, NOT the current/active one.
+ * The current version might be an older rollback, but code should match the latest push.
+ * Drafts are excluded since they haven't been deployed yet.
+ */
+export declare function fetchServerPersona(apiKey: string, agentId: string): Promise<{
+    persona: string;
+    version: number;
+} | null>;
+/**
+ * Compare server persona with local persona.
+ * Returns true if they differ (drift detected).
+ */
+export declare function comparePersona(serverPersona: string | null, localPersona: string): boolean;
+/**
+ * Check for persona drift between server and local code.
+ * Returns drift info if drift detected, null otherwise.
+ */
+export declare function checkPersonaDrift(apiKey: string, agentId: string): Promise<PersonaDrift | null>;
+/**
+ * Display a colored diff between two strings.
+ */
+export declare function showColoredDiff(oldText: string, newText: string, oldLabel?: string, newLabel?: string): void;
+/**
+ * Display a diff between server and local persona.
+ */
+export declare function showPersonaDiff(serverPersona: string | null, localPersona: string): void;
+/**
+ * Display a compact drift warning for compile flow.
+ */
+export declare function showDriftWarning(drift: PersonaDrift): void;
+/**
+ * Fetch the agent name from the server.
+ */
+export declare function fetchServerName(apiKey: string, agentId: string): Promise<string | null>;
+/**
+ * Check for name drift between server and local code.
+ */
+export declare function checkNameDrift(apiKey: string, agentId: string): Promise<NameDrift | null>;
+/**
+ * Display name drift info.
+ */
+export declare function showNameDiff(serverName: string | null, localName: string): void;