@agentuity/cli 0.0.51 → 0.0.52

package/dist/cmd/auth/whoami.js

@@ -0,0 +1,68 @@
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { whoami } from '@agentuity/server';
+import { getCommand } from '../../command-prefix';
+import { z } from 'zod';
+const WhoamiResponseSchema = z.object({
+    userId: z.string().describe('Unique user identifier'),
+    firstName: z.string().describe('User first name'),
+    lastName: z.string().describe('User last name'),
+    organizations: z
+        .array(z.object({
+        id: z.string().describe('Organization ID'),
+        name: z.string().describe('Organization name'),
+    }))
+        .describe('Organizations the user belongs to'),
+});
+export const whoamiCommand = createSubcommand({
+    name: 'whoami',
+    description: 'Display information about the currently authenticated user',
+    tags: ['read-only', 'fast', 'requires-auth'],
+    requires: { auth: true, apiClient: true },
+    idempotent: true,
+    schema: {
+        response: WhoamiResponseSchema,
+    },
+    examples: [getCommand('auth whoami'), getCommand('--json auth whoami')],
+    async handler(ctx) {
+        const { apiClient, auth, options } = ctx;
+        if (!apiClient) {
+            throw new Error('API client is not available. This is likely a configuration or initialization issue.');
+        }
+        const user = await tui.spinner({
+            message: 'Fetching user information',
+            clearOnSuccess: true,
+            callback: () => {
+                return whoami(apiClient);
+            },
+        });
+        const result = {
+            userId: auth?.userId || '',
+            firstName: user.firstName,
+            lastName: user.lastName,
+            organizations: user.organizations,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            const fullName = `${user.firstName} ${user.lastName}`;
+            tui.newline();
+            console.log(tui.bold('Currently logged in as:'));
+            tui.newline();
+            console.log(`  ${tui.padRight('Name:', 15, ' ')} ${tui.bold(fullName)}`);
+            console.log(`  ${tui.padRight('User ID:', 15, ' ')} ${tui.muted(auth?.userId || '')}`);
+            tui.newline();
+            if (user.organizations.length > 0) {
+                console.log(tui.bold('Organizations:'));
+                tui.newline();
+                for (const org of user.organizations) {
+                    console.log(`  ${tui.padRight(org.name, 30, ' ')} ${tui.muted(org.id)}`);
+                }
+            }
+            tui.newline();
+        }
+        return result;
+    },
+});
+//# sourceMappingURL=whoami.js.map

package/dist/cmd/auth/whoami.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.js","sourceRoot":"","sources":["../../../src/cmd/auth/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;IACrD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC;IACjD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAC/C,aAAa,EAAE,CAAC;SACd,KAAK,CACL,CAAC,CAAC,MAAM,CAAC;QACR,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC1C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC;KAC9C,CAAC,CACF;SACA,QAAQ,CAAC,mCAAmC,CAAC;CAC/C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,aAAa,GAAG,gBAAgB,CAAC;IAC7C,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,4DAA4D;IACzE,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,CAAC;IAC5C,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;IACzC,UAAU,EAAE,IAAI;IAChB,MAAM,EAAE;QACP,QAAQ,EAAE,oBAAoB;KAC9B;IACD,QAAQ,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;IAEvE,KAAK,CAAC,OAAO,CAAC,GAAG;QAChB,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,GAAG,CAAC;QAEzC,IAAI,CAAC,SAAS,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACd,sFAAsF,CACtF,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC;YAC9B,OAAO,EAAE,2BAA2B;YACpC,cAAc,EAAE,IAAI;YACpB,QAAQ,EAAE,GAAG,EAAE;gBACd,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC;YAC1B,CAAC;SACD,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG;YACd,MAAM,EAAE,IAAI,EAAE,MAAM,IAAI,EAAE;YAC1B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,aAAa,EAAE,IAAI,CAAC,aAAa;SACjC,CAAC;QAEF,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YAClB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9C,CAAC;aAAM,CAAC;YACP,MAAM,QAAQ,GAAG,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAEtD,GAAG,CAAC,OAAO,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC;YACjD,GAAG,CAAC,OAAO,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACzE,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;YACvF,GAAG,CAAC,OAAO,EAAE,CAAC;YAEd,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACnC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBACxC,GAAG,CAAC,OAAO,EAAE,CAAC;gBACd,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBACtC,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC1E,CAAC;YACF,CAAC;YACD,GAAG,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;QAED,OAAO,MAAM,CAAC;IACf,CAAC;CACD,CAAC,CAAC"}

package/dist/cmd/build/ast.js

@@ -0,0 +1,608 @@
+import * as acornLoose from 'acorn-loose';
+import { basename, dirname, relative } from 'node:path';
+import { generate } from 'astring';
+import { createLogger } from '@agentuity/server';
+function parseObjectExpressionToMap(expr) {
+    const result = new Map();
+    for (const prop of expr.properties) {
+        switch (prop.value.type) {
+            case 'Literal': {
+                const value = prop.value;
+                result.set(prop.key.name, value.value);
+                break;
+            }
+            default: {
+                console.warn('AST value type %s of metadata key: %s not supported', prop.value.type, prop.key.name);
+            }
+        }
+    }
+    return result;
+}
+function createObjectPropertyNode(key, value) {
+    return {
+        type: 'Property',
+        kind: 'init',
+        key: {
+            type: 'Identifier',
+            name: key,
+        },
+        value: {
+            type: 'Literal',
+            value,
+        },
+    };
+}
+function createNewMetadataNode() {
+    return {
+        type: 'Property',
+        kind: 'init',
+        key: {
+            type: 'Identifier',
+            name: 'metadata',
+        },
+        value: {
+            type: 'ObjectExpression',
+            properties: [],
+        },
+    };
+}
+function hash(...val) {
+    const hasher = new Bun.CryptoHasher('sha256');
+    val.map((val) => hasher.update(val));
+    return hasher.digest().toHex();
+}
+function hashSHA1(...val) {
+    const hasher = new Bun.CryptoHasher('sha1');
+    val.map((val) => hasher.update(val));
+    return hasher.digest().toHex();
+}
+export function getDevmodeDeploymentId(projectId, endpointId) {
+    return `devmode_${hashSHA1(projectId, endpointId)}`;
+}
+function getAgentId(projectId, deploymentId, filename, version) {
+    return `agent_${hashSHA1(projectId, deploymentId, filename, version)}`;
+}
+function getEvalId(projectId, deploymentId, filename, name, version) {
+    return `eval_${hashSHA1(projectId, deploymentId, filename, name, version)}`;
+}
+function generateRouteId(projectId, deploymentId, type, method, filename, path, version) {
+    return `route_${hashSHA1(projectId, deploymentId, type, method, filename, path, version)}`;
+}
+function generateStableAgentId(projectId, name) {
+    return `agentid_${hashSHA1(projectId, name)}`.substring(0, 64);
+}
+function generateStableEvalId(projectId, agentId, name) {
+    return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+}
+function augmentAgentMetadataNode(projectId, id, name, rel, version, ast, propvalue, filename) {
+    const metadata = parseObjectExpressionToMap(propvalue);
+    if (!metadata.has('name')) {
+        const location = ast.loc?.start ? ` on line ${ast.loc.start}` : '';
+        throw new Error(`missing required metadata.name in ${filename}${location}. This Agent should have a unique and human readable name for this project.`);
+    }
+    if (metadata.has('identifier') && name !== metadata.get('identifier')) {
+        const location = ast.loc?.start ? ` on line ${ast.loc.start}` : '';
+        throw new Error(`metadata.identifier (${metadata.get('identifier')}) in ${filename}${location} is mismatched (${name}). This is an internal error.`);
+    }
+    const descriptionNode = propvalue.properties.find((x) => x.key.name === 'description')?.value;
+    const description = descriptionNode ? descriptionNode.value : '';
+    const agentId = generateStableAgentId(projectId, name);
+    metadata.set('version', version);
+    metadata.set('identifier', name);
+    metadata.set('filename', rel);
+    metadata.set('id', id);
+    metadata.set('agentId', agentId);
+    metadata.set('description', description);
+    propvalue.properties.push(createObjectPropertyNode('id', id), createObjectPropertyNode('agentId', agentId), createObjectPropertyNode('version', version), createObjectPropertyNode('identifier', name), createObjectPropertyNode('filename', rel), createObjectPropertyNode('description', description));
+    const newsource = generate(ast);
+    // Evals imports are now handled in registry.generated.ts
+    return [newsource, metadata];
+}
+function createAgentMetadataNode(id, name, rel, version, ast, callargexp, _filename) {
+    const newmetadata = createNewMetadataNode();
+    const md = new Map();
+    md.set('id', id);
+    md.set('version', version);
+    md.set('name', name);
+    md.set('identifier', name);
+    md.set('filename', rel);
+    for (const [key, value] of md) {
+        newmetadata.value.properties.push(createObjectPropertyNode(key, value));
+    }
+    callargexp.properties.push(newmetadata);
+    const newsource = generate(ast);
+    // Evals imports are now handled in registry.generated.ts
+    return [newsource, md];
+}
+function camelToKebab(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+function setLiteralValue(literal, value) {
+    literal.value = value;
+    if (literal.raw !== undefined) {
+        literal.raw = JSON.stringify(value);
+    }
+}
+function augmentEvalMetadataNode(projectId, agentId, id, name, rel, version, _ast, metadataObj, _filename) {
+    const metadata = parseObjectExpressionToMap(metadataObj);
+    // Name can come from metadata.name or variable name (already resolved in caller)
+    // If metadata doesn't have name, we'll add it from the resolved name
+    if (!metadata.has('name')) {
+        metadataObj.properties.push(createObjectPropertyNode('name', name));
+    }
+    const descriptionNode = metadataObj.properties.find((x) => x.key.name === 'description')?.value;
+    const description = descriptionNode ? descriptionNode.value : '';
+    const effectiveAgentId = agentId || '';
+    const _evalId = getEvalId(projectId, effectiveAgentId, rel, name, version); // Deployment-specific ID (not used, kept for potential future use)
+    const stableEvalId = generateStableEvalId(projectId, effectiveAgentId, name);
+    // Check if id, version, identifier, filename, evalId already exist
+    const existingKeys = new Set();
+    for (const prop of metadataObj.properties) {
+        if (prop.key.type === 'Identifier') {
+            existingKeys.add(prop.key.name);
+        }
+    }
+    // Add or update metadata properties
+    if (!existingKeys.has('id')) {
+        metadataObj.properties.push(createObjectPropertyNode('id', id));
+    }
+    else {
+        // Update existing id
+        for (const prop of metadataObj.properties) {
+            if (prop.key.type === 'Identifier' && prop.key.name === 'id') {
+                if (prop.value.type === 'Literal') {
+                    setLiteralValue(prop.value, id);
+                }
+                break;
+            }
+        }
+    }
+    if (!existingKeys.has('version')) {
+        metadataObj.properties.push(createObjectPropertyNode('version', version));
+    }
+    else {
+        for (const prop of metadataObj.properties) {
+            if (prop.key.type === 'Identifier' && prop.key.name === 'version') {
+                if (prop.value.type === 'Literal') {
+                    setLiteralValue(prop.value, version);
+                }
+                break;
+            }
+        }
+    }
+    if (!existingKeys.has('identifier')) {
+        metadataObj.properties.push(createObjectPropertyNode('identifier', name));
+    }
+    else {
+        for (const prop of metadataObj.properties) {
+            if (prop.key.type === 'Identifier' && prop.key.name === 'identifier') {
+                if (prop.value.type === 'Literal') {
+                    setLiteralValue(prop.value, name);
+                }
+                break;
+            }
+        }
+    }
+    if (!existingKeys.has('filename')) {
+        metadataObj.properties.push(createObjectPropertyNode('filename', rel));
+    }
+    else {
+        for (const prop of metadataObj.properties) {
+            if (prop.key.type === 'Identifier' && prop.key.name === 'filename') {
+                if (prop.value.type === 'Literal') {
+                    setLiteralValue(prop.value, rel);
+                }
+                break;
+            }
+        }
+    }
+    if (!existingKeys.has('evalId')) {
+        metadataObj.properties.push(createObjectPropertyNode('evalId', stableEvalId));
+    }
+    else {
+        for (const prop of metadataObj.properties) {
+            if (prop.key.type === 'Identifier' && prop.key.name === 'evalId') {
+                if (prop.value.type === 'Literal') {
+                    setLiteralValue(prop.value, stableEvalId);
+                }
+                break;
+            }
+        }
+    }
+    if (!existingKeys.has('description')) {
+        metadataObj.properties.push(createObjectPropertyNode('description', description));
+    }
+    else {
+        for (const prop of metadataObj.properties) {
+            if (prop.key.type === 'Identifier' && prop.key.name === 'description') {
+                if (prop.value.type === 'Literal') {
+                    setLiteralValue(prop.value, description);
+                }
+                break;
+            }
+        }
+    }
+}
+export function parseEvalMetadata(rootDir, filename, contents, projectId, deploymentId, agentId) {
+    const logLevel = (process.env.AGENTUITY_LOG_LEVEL || 'info');
+    const logger = createLogger(logLevel);
+    logger.trace(`Parsing evals from ${filename}`);
+    const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
+    const rel = relative(rootDir, filename);
+    const version = hash(contents);
+    const evals = [];
+    // Find all exported agent.createEval() calls
+    for (const body of ast.body) {
+        let variableDeclaration;
+        // Only process exported VariableDeclarations
+        if (body.type === 'ExportNamedDeclaration') {
+            const exportDecl = body;
+            if (exportDecl.declaration?.type === 'VariableDeclaration') {
+                variableDeclaration = exportDecl.declaration;
+            }
+        }
+        if (variableDeclaration) {
+            for (const vardecl of variableDeclaration.declarations) {
+                if (vardecl.type === 'VariableDeclarator' && vardecl.init?.type === 'CallExpression') {
+                    const call = vardecl.init;
+                    if (call.callee.type === 'MemberExpression') {
+                        const memberExpr = call.callee;
+                        const object = memberExpr.object;
+                        const property = memberExpr.property;
+                        if (object.type === 'Identifier' &&
+                            object.name === 'agent' &&
+                            property.type === 'Identifier' &&
+                            property.name === 'createEval') {
+                            // Found agent.createEval() call
+                            if (call.arguments.length > 0) {
+                                const firstArg = call.arguments[0];
+                                if (firstArg.type === 'ObjectExpression') {
+                                    const evalConfig = firstArg;
+                                    let evalName;
+                                    let evalDescription;
+                                    let variableName;
+                                    let metadataObj;
+                                    // Capture variable name if available
+                                    if (vardecl.id.type === 'Identifier') {
+                                        variableName = vardecl.id.name;
+                                    }
+                                    // Extract metadata from the eval config
+                                    for (const prop of evalConfig.properties) {
+                                        if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
+                                            if (prop.value.type === 'ObjectExpression') {
+                                                metadataObj = prop.value;
+                                                for (const metaProp of metadataObj.properties) {
+                                                    if (metaProp.key.type === 'Identifier') {
+                                                        if (metaProp.key.name === 'name' &&
+                                                            metaProp.value.type === 'Literal') {
+                                                            evalName = metaProp.value.value;
+                                                        }
+                                                        else if (metaProp.key.name === 'description' &&
+                                                            metaProp.value.type === 'Literal') {
+                                                            evalDescription = metaProp.value.value;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    // Use metadata.name if provided, otherwise use variable name
+                                    // Throw error if neither is available (should never happen)
+                                    let finalName;
+                                    if (evalName) {
+                                        finalName = evalName;
+                                    }
+                                    else if (variableName) {
+                                        finalName = camelToKebab(variableName);
+                                    }
+                                    else {
+                                        throw new Error('Eval is missing a name. Please provide metadata.name or use a named export.');
+                                    }
+                                    logger.trace(`Found eval: ${finalName}${evalDescription ? ` - ${evalDescription}` : ''}`);
+                                    const evalId = getEvalId(projectId, deploymentId, rel, finalName, version);
+                                    // Inject metadata into AST if metadata object exists
+                                    let stableEvalId;
+                                    const effectiveAgentId = agentId || '';
+                                    if (metadataObj) {
+                                        augmentEvalMetadataNode(projectId, effectiveAgentId, evalId, finalName, rel, version, ast, metadataObj, filename);
+                                        // Extract evalId from metadata after augmentation
+                                        const metadata = parseObjectExpressionToMap(metadataObj);
+                                        stableEvalId =
+                                            metadata.get('evalId') ||
+                                                generateStableEvalId(projectId, effectiveAgentId, finalName);
+                                    }
+                                    else {
+                                        // If no metadata object, generate stable evalId
+                                        stableEvalId = generateStableEvalId(projectId, effectiveAgentId, finalName);
+                                    }
+                                    evals.push({
+                                        filename: rel,
+                                        id: evalId,
+                                        version,
+                                        identifier: finalName,
+                                        name: finalName,
+                                        evalId: stableEvalId,
+                                        description: evalDescription,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Check for duplicate eval names in the same file
+    // This prevents hash collisions when projectId/deploymentId are empty
+    const seenNames = new Map();
+    for (const evalItem of evals) {
+        const count = seenNames.get(evalItem.name) || 0;
+        seenNames.set(evalItem.name, count + 1);
+    }
+    const duplicates = [];
+    for (const [name, count] of seenNames.entries()) {
+        if (count > 1) {
+            duplicates.push(name);
+        }
+    }
+    if (duplicates.length > 0) {
+        throw new Error(`Duplicate eval names found in ${rel}: ${duplicates.join(', ')}. ` +
+            'Eval names must be unique within the same file to prevent ID collisions.');
+    }
+    const newsource = generate(ast);
+    logger.trace(`Parsed ${evals.length} eval(s) from ${filename}`);
+    return [newsource, evals];
+}
+export async function parseAgentMetadata(rootDir, filename, contents, projectId, deploymentId) {
+    const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
+    let exportName;
+    const rel = relative(rootDir, filename);
+    const name = basename(dirname(filename));
+    const version = hash(contents);
+    const id = getAgentId(projectId, deploymentId, rel, version);
+    let result;
+    for (const body of ast.body) {
+        if (body.type === 'ExportDefaultDeclaration') {
+            if (body.declaration?.type === 'CallExpression') {
+                const call = body.declaration;
+                if (call.callee.name === 'createAgent') {
+                    for (const callarg of call.arguments) {
+                        const callargexp = callarg;
+                        for (const prop of callargexp.properties) {
+                            if (prop.key.type === 'Identifier' && prop.key.name === 'metadata') {
+                                result = augmentAgentMetadataNode(projectId, id, name, rel, version, ast, prop.value, filename);
+                                break;
+                            }
+                        }
+                        if (!result) {
+                            result = createAgentMetadataNode(id, name, rel, version, ast, callargexp, filename);
+                        }
+                        break;
+                    }
+                }
+            }
+            if (!result) {
+                const identifier = body.declaration;
+                exportName = identifier.name;
+                break;
+            }
+        }
+    }
+    if (!result && !exportName) {
+        throw new Error(`could not find default export for ${filename} using ${rootDir}`);
+    }
+    if (!result) {
+        for (const body of ast.body) {
+            if (body.type === 'VariableDeclaration') {
+                for (const vardecl of body.declarations) {
+                    if (vardecl.type === 'VariableDeclarator' && vardecl.id.type === 'Identifier') {
+                        const identifier = vardecl.id;
+                        if (identifier.name === exportName) {
+                            if (vardecl.init?.type === 'CallExpression') {
+                                const call = vardecl.init;
+                                if (call.callee.name === 'createAgent') {
+                                    for (const callarg of call.arguments) {
+                                        const callargexp = callarg;
+                                        for (const prop of callargexp.properties) {
+                                            if (prop.key.type === 'Identifier' &&
+                                                prop.key.name === 'metadata') {
+                                                result = augmentAgentMetadataNode(projectId, id, name, rel, version, ast, prop.value, filename);
+                                                break;
+                                            }
+                                        }
+                                        if (!result) {
+                                            result = createAgentMetadataNode(id, name, rel, version, ast, callargexp, filename);
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (!result) {
+        throw new Error(`error parsing: ${filename}. could not find an proper createAgent defined in this file`);
+    }
+    // Parse evals from eval.ts file in the same directory
+    const logLevel = (process.env.AGENTUITY_LOG_LEVEL || 'info');
+    const logger = createLogger(logLevel);
+    const agentDir = dirname(filename);
+    const evalsPath = `${agentDir}/eval.ts`;
+    logger.trace(`Checking for evals file at ${evalsPath}`);
+    const evalsFile = Bun.file(evalsPath);
+    if (await evalsFile.exists()) {
+        logger.trace(`Found evals file at ${evalsPath}, parsing...`);
+        const evalsSource = await evalsFile.text();
+        const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
+        const evalsContents = transpiler.transformSync(evalsSource);
+        const agentId = result[1].get('agentId') || '';
+        const [, evals] = parseEvalMetadata(rootDir, evalsPath, evalsContents, projectId, deploymentId, agentId);
+        if (evals.length > 0) {
+            logger.trace(`Adding ${evals.length} eval(s) to agent metadata for ${name}`);
+            result[1].set('evals', JSON.stringify(evals));
+        }
+        else {
+            logger.trace(`No evals found in ${evalsPath}`);
+        }
+    }
+    else {
+        logger.trace(`No evals file found at ${evalsPath}`);
+    }
+    return result;
+}
+export async function parseRoute(rootDir, filename, projectId, deploymentId) {
+    const contents = await Bun.file(filename).text();
+    const version = hash(contents);
+    const ast = acornLoose.parse(contents, { ecmaVersion: 'latest', sourceType: 'module' });
+    let exportName;
+    let variableName;
+    for (const body of ast.body) {
+        if (body.type === 'ExportDefaultDeclaration') {
+            const identifier = body.declaration;
+            exportName = identifier.name;
+            break;
+        }
+    }
+    if (!exportName) {
+        throw new Error(`could not find default export for ${filename} using ${rootDir}`);
+    }
+    for (const body of ast.body) {
+        if (body.type === 'VariableDeclaration') {
+            for (const vardecl of body.declarations) {
+                if (vardecl.type === 'VariableDeclarator' && vardecl.id.type === 'Identifier') {
+                    const identifier = vardecl.id;
+                    if (identifier.name === exportName) {
+                        if (vardecl.init?.type === 'CallExpression') {
+                            const call = vardecl.init;
+                            if (call.callee.name === 'createRouter') {
+                                variableName = identifier.name;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (!variableName) {
+        throw new Error(`error parsing: ${filename}. could not find an proper createRouter defined in this file`);
+    }
+    const rel = relative(rootDir, filename);
+    const dir = dirname(filename);
+    const name = basename(dir);
+    // Detect if this is a subagent route and build proper path
+    const relativePath = relative(rootDir, dir)
+        .replace(/^src\/agents\//, '')
+        .replace(/^src\/apis\//, '');
+    const pathParts = relativePath.split('/').filter(Boolean);
+    const isSubagent = pathParts.length === 2 && filename.includes('src/agents');
+    const routeName = isSubagent ? pathParts.join('/') : name;
+    const routes = [];
+    const routePrefix = filename.includes('src/agents') ? '/agent' : '/api';
+    for (const body of ast.body) {
+        if (body.type === 'ExpressionStatement') {
+            const statement = body;
+            const callee = statement.expression.callee;
+            if (callee.object.type === 'Identifier') {
+                const identifier = callee.object;
+                if (identifier.name === variableName) {
+                    let method = callee.property.name;
+                    let type = 'api';
+                    const action = statement.expression.arguments[0];
+                    let suffix = '';
+                    let config;
+                    switch (method) {
+                        case 'get':
+                        case 'put':
+                        case 'post':
+                        case 'patch':
+                        case 'delete': {
+                            const theaction = action;
+                            if (theaction.type === 'Literal') {
+                                suffix = theaction.value;
+                                break;
+                            }
+                            break;
+                        }
+                        case 'stream':
+                        case 'sse':
+                        case 'websocket': {
+                            type = method;
+                            method = 'post';
+                            const theaction = action;
+                            if (theaction.type === 'Literal') {
+                                suffix = theaction.value;
+                                break;
+                            }
+                            break;
+                        }
+                        case 'sms': {
+                            type = method;
+                            method = 'post';
+                            const theaction = action;
+                            if (theaction.type === 'ObjectExpression') {
+                                config = {};
+                                theaction.properties.forEach((p) => {
+                                    if (p.value.type === 'Literal') {
+                                        const literal = p.value;
+                                        config[p.key.name] = literal.value;
+                                    }
+                                });
+                                const number = theaction.properties.find((p) => p.key.name === 'number');
+                                if (number && number.value.type === 'Literal') {
+                                    const phoneNumber = number.value;
+                                    suffix = hash(phoneNumber.value);
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+                        case 'email': {
+                            type = method;
+                            method = 'post';
+                            const theaction = action;
+                            if (theaction.type === 'Literal') {
+                                const email = theaction.value;
+                                suffix = hash(email);
+                                break;
+                            }
+                            break;
+                        }
+                        case 'cron': {
+                            type = method;
+                            method = 'post';
+                            const theaction = action;
+                            if (theaction.type === 'Literal') {
+                                const number = theaction.value;
+                                suffix = hash(number);
+                                break;
+                            }
+                            break;
+                        }
+                    }
+                    const thepath = `${routePrefix}/${routeName}/${suffix}`
+                        .replaceAll(/\/{2,}/g, '/')
+                        .replaceAll(/\/$/g, '');
+                    const id = generateRouteId(projectId, deploymentId, type, method, rel, thepath, version);
+                    routes.push({
+                        id,
+                        method: method,
+                        type: type,
+                        filename: rel,
+                        path: thepath,
+                        version,
+                        config,
+                    });
+                }
+            }
+        }
+    }
+    return routes;
+}
+//# sourceMappingURL=ast.js.map