lua-cli 3.1.0 → 3.2.0-alpha.1

package/dist/utils/sync-helpers.js

@@ -0,0 +1,190 @@
+/**
+ * Sync Helpers
+ * Utilities for detecting drift between server state and local code
+ */
+import { diffLines } from 'diff';
+import { BASE_URLS } from '../config/constants.js';
+import { loadPersonaFromCode, loadNameFromCode } from './agent-code-utils.js';
+import PersonaApi from '../api/persona.api.service.js';
+import AgentApi from '../api/agent.api.service.js';
+// ANSI color codes
+const colors = {
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    gray: '\x1b[90m',
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+};
+/**
+ * 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 async function fetchServerPersona(apiKey, agentId) {
+    try {
+        const personaApi = new PersonaApi(BASE_URLS.API, apiKey, agentId);
+        const latestPublished = await personaApi.getLatestPublishedVersion();
+        if (latestPublished && latestPublished.persona) {
+            return {
+                persona: latestPublished.persona,
+                version: latestPublished.version,
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        // Silently fail - network issues shouldn't block compilation
+        return null;
+    }
+}
+/**
+ * Compare server persona with local persona.
+ * Returns true if they differ (drift detected).
+ */
+export function comparePersona(serverPersona, localPersona) {
+    if (serverPersona === null) {
+        return false; // No server state to compare against
+    }
+    // Normalize whitespace for comparison
+    const normalizedServer = serverPersona.trim();
+    const normalizedLocal = localPersona.trim();
+    return normalizedServer !== normalizedLocal;
+}
+/**
+ * Check for persona drift between server and local code.
+ * Returns drift info if drift detected, null otherwise.
+ */
+export async function checkPersonaDrift(apiKey, agentId) {
+    const localPersona = loadPersonaFromCode();
+    const serverData = await fetchServerPersona(apiKey, agentId);
+    const hasDrift = comparePersona(serverData?.persona || null, localPersona);
+    if (!hasDrift) {
+        return null;
+    }
+    return {
+        hasDrift: true,
+        serverPersona: serverData?.persona || null,
+        localPersona,
+        serverVersion: serverData?.version,
+    };
+}
+/**
+ * Display a colored diff between two strings.
+ */
+export function showColoredDiff(oldText, newText, oldLabel = 'Server', newLabel = 'Local') {
+    if (!oldText && !newText) {
+        console.log(colors.gray + '(both empty)' + colors.reset);
+        return;
+    }
+    if (!oldText) {
+        console.log(colors.green + `+ (${newLabel} only - no ${oldLabel} content)` + colors.reset);
+        return;
+    }
+    if (!newText) {
+        console.log(colors.red + `- (${oldLabel} only - no ${newLabel} content)` + colors.reset);
+        return;
+    }
+    const diff = diffLines(oldText, newText);
+    diff.forEach(part => {
+        if (part.added) {
+            // Added in local (green)
+            const lines = part.value.split('\n').filter(l => l);
+            lines.forEach(line => {
+                console.log(colors.green + '+ ' + line + colors.reset);
+            });
+        }
+        else if (part.removed) {
+            // Removed from server (red)
+            const lines = part.value.split('\n').filter(l => l);
+            lines.forEach(line => {
+                console.log(colors.red + '- ' + line + colors.reset);
+            });
+        }
+        else {
+            // Unchanged - show abbreviated context
+            const lines = part.value.split('\n').filter(l => l);
+            if (lines.length <= 6) {
+                lines.forEach(line => {
+                    console.log(colors.gray + '  ' + line + colors.reset);
+                });
+            }
+            else {
+                // Show first 3 and last 3 lines
+                lines.slice(0, 3).forEach(line => {
+                    console.log(colors.gray + '  ' + line + colors.reset);
+                });
+                console.log(colors.gray + `  ... (${lines.length - 6} unchanged lines) ...` + colors.reset);
+                lines.slice(-3).forEach(line => {
+                    console.log(colors.gray + '  ' + line + colors.reset);
+                });
+            }
+        }
+    });
+}
+/**
+ * Display a diff between server and local persona.
+ */
+export function showPersonaDiff(serverPersona, localPersona) {
+    console.log('\n' + '='.repeat(60));
+    console.log(colors.bold + 'PERSONA DIFF' + colors.reset);
+    console.log(colors.red + '- Server (deployed)' + colors.reset + '  ' + colors.green + '+ Local (code)' + colors.reset);
+    console.log('='.repeat(60) + '\n');
+    showColoredDiff(serverPersona || '', localPersona, 'Server', 'Local');
+    console.log('\n' + '='.repeat(60) + '\n');
+}
+/**
+ * Display a compact drift warning for compile flow.
+ */
+export function showDriftWarning(drift) {
+    console.log('\n⚠️  Persona drift detected!');
+    console.log(`   Server version ${drift.serverVersion || 'unknown'} differs from local code.`);
+}
+/**
+ * Fetch the agent name from the server.
+ */
+export async function fetchServerName(apiKey, agentId) {
+    try {
+        const agentApi = new AgentApi(BASE_URLS.API, apiKey);
+        const response = await agentApi.getAgent(agentId);
+        if (response.success && response.data?.name) {
+            return response.data.name;
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Check for name drift between server and local code.
+ */
+export async function checkNameDrift(apiKey, agentId) {
+    const localName = loadNameFromCode();
+    const serverName = await fetchServerName(apiKey, agentId);
+    if (serverName === null) {
+        return null; // No server state to compare against
+    }
+    const hasDrift = serverName.trim() !== localName.trim();
+    if (!hasDrift) {
+        return null;
+    }
+    return {
+        hasDrift: true,
+        serverName,
+        localName,
+    };
+}
+/**
+ * Display name drift info.
+ */
+export function showNameDiff(serverName, localName) {
+    console.log('\n' + '='.repeat(60));
+    console.log(colors.bold + 'NAME DIFF' + colors.reset);
+    console.log('='.repeat(60));
+    console.log(colors.red + `- Server: "${serverName || '(none)'}"` + colors.reset);
+    console.log(colors.green + `+ Local:  "${localName || '(none)'}"` + colors.reset);
+    console.log('='.repeat(60) + '\n');
+}

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

@@ -31,10 +31,3 @@ export declare function extractToolsFromDeployData(deployData: any): ToolData[];
  * @returns True if .env file exists
  */
 export declare function hasEnvFile(): boolean;
-/**
- * Checks if config has environment variables defined.
- *
- * @param config - Skill configuration
- * @returns True if config has environment variables
- */
-export declare function hasConfigEnvVars(config: any): boolean;

package/dist/utils/test-helpers.js

@@ -81,12 +81,3 @@ export function extractToolsFromDeployData(deployData) {
 export function hasEnvFile() {
     return fs.existsSync(path.join(process.cwd(), '.env'));
 }
-/**
- * Checks if config has environment variables defined.
- *
- * @param config - Skill configuration
- * @returns True if config has environment variables
- */
-export function hasConfigEnvVars(config) {
-    return config?.skill?.env && Object.keys(config.skill.env).length > 0;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.1.0",
+  "version": "3.2.0-alpha.1",
   "description": "Build, test, and deploy AI agents with custom tools, webhooks, and scheduled jobs. Features LuaAgent unified configuration, streaming chat, and batch deployment.",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",
@@ -67,6 +67,7 @@
     "autoprefixer": "^10.4.21",
     "chalk": "^5.3.0",
     "commander": "^14.0.1",
+    "diff": "^8.0.2",
     "dotenv": "^17.2.3",
     "esbuild": "^0.25.10",
     "inquirer": "^12.9.6",
@@ -84,6 +85,7 @@
     "zod-to-json-schema": "^3.24.6"
   },
   "devDependencies": {
+    "@types/diff": "^7.0.2",
     "@types/inquirer": "^9.0.9",
     "@types/jest": "^29.5.8",
     "@types/js-yaml": "^4.0.9",

package/template/README.md

@@ -21,7 +21,7 @@ lua push all --force --auto-deploy
 your-project/
 ├── src/
 │   └── index.ts          # Your agent configuration
-├── lua.skill.yaml        # Agent metadata (auto-managed)
+├── lua.skill.yaml        # State manifest (IDs + versions only; auto-managed)
 ├── package.json          # Dependencies
 └── tsconfig.json         # TypeScript config
 ```

package/template/lua.skill.yaml

@@ -1 +1,11 @@
+agent:
+  agentId: ""
+  orgId: ""
+
+# State-only manifest (managed by the CLI)
 skills: []
+webhooks: []
+jobs: []
+preprocessors: []
+postprocessors: []
+mcpServers: []

package/template/package.json

@@ -20,7 +20,7 @@
     "inquirer": "^12.9.6",
     "stripe": "^17.5.0",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^3.1.0",
+    "lua-cli": "^3.2.0-alpha.1",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"

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

@@ -1,23 +0,0 @@
-/**
- * Agent Management Utilities
- * Handles LuaAgent persona synchronization with lua.skill.yaml
- */
-/**
- * Syncs the agent's name and persona with lua.skill.yaml.
- * This ensures the YAML configuration reflects the agent definition in code.
- *
- * @param agentMetadata - Agent metadata extracted from LuaAgent
- */
-export declare function syncAgentPersonaWithYaml(agentMetadata: {
-    name: string;
-    persona: string;
-}): Promise<void>;
-/**
- * Reads the agent persona from lua.skill.yaml.
- * This can be used to ensure the code and YAML are in sync.
- *
- * @returns Agent persona from YAML, or null if not found
- */
-export declare function readAgentPersonaFromYaml(): {
-    persona?: string;
-} | null;

package/dist/utils/agent-management.js

@@ -1,67 +0,0 @@
-/**
- * Agent Management Utilities
- * Handles LuaAgent persona synchronization with lua.skill.yaml
- */
-import fs from "fs";
-import path from "path";
-import yaml from "js-yaml";
-import { COMPILE_FILES, YAML_FORMAT } from '../config/compile.constants.js';
-/**
- * Syncs the agent's name and persona with lua.skill.yaml.
- * This ensures the YAML configuration reflects the agent definition in code.
- *
- * @param agentMetadata - Agent metadata extracted from LuaAgent
- */
-export async function syncAgentPersonaWithYaml(agentMetadata) {
-    const yamlPath = path.join(process.cwd(), COMPILE_FILES.LUA_SKILL_YAML);
-    // Read existing YAML config
-    let config = {};
-    if (fs.existsSync(yamlPath)) {
-        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-        config = yaml.load(yamlContent);
-    }
-    // Update agent section with persona
-    config.agent = {
-        ...config.agent,
-        persona: agentMetadata.persona
-    };
-    // Store agent name as a comment or in metadata (YAML doesn't have an agentName field)
-    // The agent name is primarily for the LuaAgent in code
-    // Write updated YAML with consistent formatting
-    const yamlContent = yaml.dump(config, {
-        indent: YAML_FORMAT.INDENT,
-        lineWidth: YAML_FORMAT.LINE_WIDTH,
-        noRefs: YAML_FORMAT.NO_REFS,
-        replacer: (key, value) => {
-            // Replace undefined values with empty strings
-            return value === undefined ? '' : value;
-        }
-    });
-    fs.writeFileSync(yamlPath, yamlContent);
-    console.log(`✅ Synced agent configuration to lua.skill.yaml`);
-}
-/**
- * Reads the agent persona from lua.skill.yaml.
- * This can be used to ensure the code and YAML are in sync.
- *
- * @returns Agent persona from YAML, or null if not found
- */
-export function readAgentPersonaFromYaml() {
-    const yamlPath = path.join(process.cwd(), COMPILE_FILES.LUA_SKILL_YAML);
-    if (!fs.existsSync(yamlPath)) {
-        return null;
-    }
-    try {
-        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
-        const config = yaml.load(yamlContent);
-        if (config.agent) {
-            return {
-                persona: config.agent.persona
-            };
-        }
-    }
-    catch (error) {
-        console.warn(`Warning: Could not read agent persona from lua.skill.yaml: ${error}`);
-    }
-    return null;
-}