@thinksoftai/cli 1.5.0 → 1.6.0

package/dist/commands/rules.js

@@ -0,0 +1,762 @@
+"use strict";
+/**
+ * Rules command - CRUD operations for agent business rules
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = list;
+exports.show = show;
+exports.create = create;
+exports.update = update;
+exports.deleteRule = deleteRule;
+exports.enable = enable;
+exports.disable = disable;
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const api = __importStar(require("../utils/api"));
+const config = __importStar(require("../utils/config"));
+const logger = __importStar(require("../utils/logger"));
+// Trigger options
+const TRIGGERS = [
+    { name: 'Before Create - Runs before a new record is saved', value: 'before_create' },
+    { name: 'After Create - Runs after a new record is saved', value: 'after_create' },
+    { name: 'Before Update - Runs before a record is updated', value: 'before_update' },
+    { name: 'After Update - Runs after a record is updated', value: 'after_update' }
+];
+// Action types
+const ACTION_TYPES = [
+    { name: 'Set Field - Set a field to a specific value', value: 'set_field' },
+    { name: 'Calculate - Compute a field using Liquid formula', value: 'calculate' },
+    { name: 'Reject - Block the operation with an error', value: 'reject' },
+    { name: 'Validate - Conditional rejection', value: 'validate' },
+    { name: 'Lookup & Set - Query another table and set field', value: 'lookup_and_set' }
+];
+// Lookup selection strategies
+const LOOKUP_SELECT_OPTIONS = [
+    { name: 'First - Return first matching record', value: 'first' },
+    { name: 'Last - Return last matching record', value: 'last' },
+    { name: 'Random - Return random match', value: 'random' },
+    { name: 'Min - Return record with minimum value', value: 'min' },
+    { name: 'Max - Return record with maximum value', value: 'max' }
+];
+// No match handling options
+const NO_MATCH_OPTIONS = [
+    { name: 'Skip - Leave field empty', value: 'skip' },
+    { name: 'Reject - Block operation with error', value: 'reject' },
+    { name: 'Default - Use a default value', value: 'default' }
+];
+/**
+ * Check authentication
+ */
+function checkAuth() {
+    if (!config.isLoggedIn()) {
+        logger.error('Not logged in');
+        logger.info('Use "thinksoft login" to authenticate');
+        return false;
+    }
+    return true;
+}
+/**
+ * Get app ID from argument or project config
+ */
+function getAppId(appId) {
+    return appId || config.getProjectConfig()?.appId;
+}
+/**
+ * List all rules for an agent
+ */
+async function list(agentSlug, appId) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId) {
+        logger.error('App ID is required');
+        logger.info('Usage: thinksoft rules <agentSlug> [appId]');
+        logger.info('Or run from a directory with thinksoft.json');
+        return;
+    }
+    if (!agentSlug) {
+        logger.error('Agent slug is required');
+        logger.info('Usage: thinksoft rules <agentSlug> [appId]');
+        return;
+    }
+    logger.header('Rules - List');
+    logger.keyValue('App ID', targetAppId);
+    logger.keyValue('Agent', agentSlug);
+    const spinner = (0, ora_1.default)('Fetching rules...').start();
+    const result = await api.getRules(targetAppId, agentSlug);
+    if (result.error) {
+        spinner.fail('Failed to fetch rules');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed('Rules retrieved');
+    const rules = result.data || result.rules || [];
+    if (rules.length === 0) {
+        logger.newLine();
+        logger.info('No rules found for this agent');
+        logger.info('Use "thinksoft rules:create <agentSlug>" to create a rule');
+        return;
+    }
+    logger.newLine();
+    logger.log(`Found ${rules.length} rule(s):`);
+    logger.newLine();
+    rules.forEach((rule, index) => {
+        const status = rule.enabled !== false ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+        const disabledText = rule.enabled === false ? chalk_1.default.gray(' [DISABLED]') : '';
+        logger.log(`  ${index + 1}. ${status} ${rule.name} (${rule.id})${disabledText}`);
+        logger.log(`     Trigger: ${rule.trigger} | Table: ${rule.table || '*'} | Priority: ${rule.priority || 10}`);
+        const actionTypes = (rule.actions || []).map((a) => a.type).join(', ');
+        logger.log(`     Actions: ${actionTypes || 'none'}`);
+        if (rule.description) {
+            logger.log(chalk_1.default.gray(`     ${rule.description}`));
+        }
+        logger.newLine();
+    });
+    logger.info('Tip: Use "thinksoft rules:show <agentSlug> <ruleId>" for details');
+}
+/**
+ * Show details for a specific rule
+ */
+async function show(agentSlug, ruleId, appId) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId || !agentSlug || !ruleId) {
+        logger.error('App ID, agent slug, and rule ID are required');
+        logger.info('Usage: thinksoft rules:show <agentSlug> <ruleId> [appId]');
+        return;
+    }
+    logger.header('Rule Details');
+    logger.keyValue('App ID', targetAppId);
+    logger.keyValue('Agent', agentSlug);
+    logger.keyValue('Rule ID', ruleId);
+    const spinner = (0, ora_1.default)('Fetching rule...').start();
+    const result = await api.getRule(targetAppId, agentSlug, ruleId);
+    if (result.error) {
+        spinner.fail('Failed to fetch rule');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed('Rule retrieved');
+    const rule = result.data || result.rule || result;
+    logger.newLine();
+    logger.log(chalk_1.default.bold(`Name: ${rule.name}`));
+    if (rule.description) {
+        logger.log(`Description: ${rule.description}`);
+    }
+    logger.log(`Status: ${rule.enabled !== false ? chalk_1.default.green('Enabled') : chalk_1.default.red('Disabled')}`);
+    logger.log(`Trigger: ${rule.trigger}`);
+    logger.log(`Table: ${rule.table || '* (all tables)'}`);
+    logger.log(`Priority: ${rule.priority || 10}`);
+    logger.newLine();
+    logger.log(chalk_1.default.bold('Condition:'));
+    logger.log(chalk_1.default.cyan(`  ${rule.condition || 'true'}`));
+    const actions = rule.actions || [];
+    logger.newLine();
+    logger.log(chalk_1.default.bold(`Actions (${actions.length}):`));
+    if (actions.length === 0) {
+        logger.log('  No actions defined');
+    }
+    else {
+        actions.forEach((action, index) => {
+            logger.newLine();
+            logger.log(`  ${index + 1}. ${chalk_1.default.yellow(action.type)}`);
+            switch (action.type) {
+                case 'set_field':
+                    logger.log(`     Field: ${action.field}`);
+                    logger.log(`     Value: ${action.value}`);
+                    break;
+                case 'calculate':
+                    logger.log(`     Field: ${action.field}`);
+                    logger.log(`     Formula: ${action.value}`);
+                    break;
+                case 'reject':
+                    logger.log(`     Message: ${action.message}`);
+                    break;
+                case 'validate':
+                    logger.log(`     Condition: ${action.condition}`);
+                    logger.log(`     Message: ${action.message}`);
+                    break;
+                case 'lookup_and_set':
+                    logger.log(`     Field: ${action.field}`);
+                    logger.log(`     Lookup Table: ${action.lookupTable}`);
+                    logger.log(`     Select By: ${action.selectBy || 'first'}`);
+                    if (action.selectField) {
+                        logger.log(`     Select Field: ${action.selectField}`);
+                    }
+                    logger.log(`     Return Field: ${action.returnField}`);
+                    logger.log(`     No Match: ${action.noMatchAction || 'skip'}`);
+                    if (action.lookupFilter) {
+                        logger.log(`     Filter: ${JSON.stringify(action.lookupFilter)}`);
+                    }
+                    break;
+            }
+        });
+    }
+    logger.newLine();
+}
+/**
+ * Create a new rule
+ */
+async function create(agentSlug, appId, options = {}) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId || !agentSlug) {
+        logger.error('App ID and agent slug are required');
+        logger.info('Usage: thinksoft rules:create <agentSlug> [appId]');
+        return;
+    }
+    let ruleData;
+    // If --data provided, use it (non-interactive)
+    if (options.data) {
+        try {
+            ruleData = JSON.parse(options.data);
+        }
+        catch {
+            logger.error('Invalid JSON data');
+            logger.info('Use valid JSON: --data \'{"name":"Rule Name", ...}\'');
+            return;
+        }
+    }
+    else {
+        // Interactive mode
+        ruleData = await promptForRule(targetAppId);
+    }
+    logger.header('Rules - Create');
+    logger.keyValue('App ID', targetAppId);
+    logger.keyValue('Agent', agentSlug);
+    logger.keyValue('Rule Name', ruleData.name);
+    const spinner = (0, ora_1.default)('Creating rule...').start();
+    const result = await api.createRule(targetAppId, agentSlug, ruleData);
+    if (result.error) {
+        spinner.fail('Failed to create rule');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed(`Rule "${ruleData.name}" created`);
+    const createdRule = result.data || result.rule || result;
+    if (createdRule.id) {
+        logger.newLine();
+        logger.log(`Rule ID: ${createdRule.id}`);
+    }
+}
+/**
+ * Update an existing rule
+ */
+async function update(agentSlug, ruleId, appId, options = {}) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId || !agentSlug || !ruleId) {
+        logger.error('App ID, agent slug, and rule ID are required');
+        logger.info('Usage: thinksoft rules:update <agentSlug> <ruleId> [appId]');
+        return;
+    }
+    let updates;
+    // If --data provided, use it
+    if (options.data) {
+        try {
+            updates = JSON.parse(options.data);
+        }
+        catch {
+            logger.error('Invalid JSON data');
+            return;
+        }
+    }
+    else if (options.enabled !== undefined || options.priority) {
+        // Quick update for enabled/priority
+        updates = {};
+        if (options.enabled !== undefined) {
+            updates.enabled = options.enabled;
+        }
+        if (options.priority) {
+            updates.priority = parseInt(options.priority);
+        }
+    }
+    else {
+        // Interactive mode - fetch current rule first
+        const spinner = (0, ora_1.default)('Fetching current rule...').start();
+        const currentResult = await api.getRule(targetAppId, agentSlug, ruleId);
+        spinner.stop();
+        if (currentResult.error) {
+            logger.error('Could not fetch current rule');
+            handleError(currentResult.error);
+            return;
+        }
+        const currentRule = currentResult.data || currentResult.rule || currentResult;
+        updates = await promptForRuleUpdate(targetAppId, currentRule);
+    }
+    logger.header('Rules - Update');
+    logger.keyValue('App ID', targetAppId);
+    logger.keyValue('Agent', agentSlug);
+    logger.keyValue('Rule ID', ruleId);
+    const spinner = (0, ora_1.default)('Updating rule...').start();
+    const result = await api.updateRule(targetAppId, agentSlug, ruleId, updates);
+    if (result.error) {
+        spinner.fail('Failed to update rule');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed('Rule updated');
+}
+/**
+ * Delete a rule
+ */
+async function deleteRule(agentSlug, ruleId, appId, options = {}) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId || !agentSlug || !ruleId) {
+        logger.error('App ID, agent slug, and rule ID are required');
+        logger.info('Usage: thinksoft rules:delete <agentSlug> <ruleId> [appId]');
+        return;
+    }
+    // Confirm deletion
+    if (!options.yes) {
+        const { confirm } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'confirm',
+                message: `Delete rule "${ruleId}"? This cannot be undone.`,
+                default: false
+            }]);
+        if (!confirm) {
+            logger.info('Cancelled');
+            return;
+        }
+    }
+    logger.header('Rules - Delete');
+    logger.keyValue('App ID', targetAppId);
+    logger.keyValue('Agent', agentSlug);
+    logger.keyValue('Rule ID', ruleId);
+    const spinner = (0, ora_1.default)('Deleting rule...').start();
+    const result = await api.deleteRule(targetAppId, agentSlug, ruleId);
+    if (result.error) {
+        spinner.fail('Failed to delete rule');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed('Rule deleted');
+}
+/**
+ * Enable a rule
+ */
+async function enable(agentSlug, ruleId, appId) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId || !agentSlug || !ruleId) {
+        logger.error('App ID, agent slug, and rule ID are required');
+        logger.info('Usage: thinksoft rules:enable <agentSlug> <ruleId> [appId]');
+        return;
+    }
+    const spinner = (0, ora_1.default)('Enabling rule...').start();
+    const result = await api.updateRule(targetAppId, agentSlug, ruleId, { enabled: true });
+    if (result.error) {
+        spinner.fail('Failed to enable rule');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed(`Rule "${ruleId}" enabled`);
+}
+/**
+ * Disable a rule
+ */
+async function disable(agentSlug, ruleId, appId) {
+    if (!checkAuth())
+        return;
+    const targetAppId = getAppId(appId);
+    if (!targetAppId || !agentSlug || !ruleId) {
+        logger.error('App ID, agent slug, and rule ID are required');
+        logger.info('Usage: thinksoft rules:disable <agentSlug> <ruleId> [appId]');
+        return;
+    }
+    const spinner = (0, ora_1.default)('Disabling rule...').start();
+    const result = await api.updateRule(targetAppId, agentSlug, ruleId, { enabled: false });
+    if (result.error) {
+        spinner.fail('Failed to disable rule');
+        handleError(result.error);
+        return;
+    }
+    spinner.succeed(`Rule "${ruleId}" disabled`);
+}
+/**
+ * Interactive prompt for creating a new rule
+ */
+async function promptForRule(appId) {
+    // Get available tables for selection
+    const schemaResult = await api.getSchema(appId);
+    const tables = schemaResult.data || [];
+    const tableChoices = [
+        { name: '* (All tables)', value: '*' },
+        ...tables.map((t) => ({ name: `${t.icon || ''} ${t.name} (${t.slug})`, value: t.slug }))
+    ];
+    // Basic info
+    const basicInfo = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Rule name:',
+            validate: (input) => input.trim() ? true : 'Rule name is required'
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description (optional):'
+        },
+        {
+            type: 'list',
+            name: 'trigger',
+            message: 'When should this rule run?',
+            choices: TRIGGERS
+        },
+        {
+            type: 'list',
+            name: 'table',
+            message: 'Which table does this rule apply to?',
+            choices: tableChoices
+        },
+        {
+            type: 'input',
+            name: 'condition',
+            message: 'Condition (Liquid template, leave empty for always):',
+            default: 'true'
+        },
+        {
+            type: 'number',
+            name: 'priority',
+            message: 'Priority (lower runs first):',
+            default: 10
+        }
+    ]);
+    // Actions
+    const actions = [];
+    let addMoreActions = true;
+    console.log();
+    console.log(chalk_1.default.cyan('Now let\'s add actions for this rule:'));
+    console.log();
+    while (addMoreActions) {
+        const action = await promptForAction(appId, tables);
+        actions.push(action);
+        const { more } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'more',
+                message: 'Add another action?',
+                default: false
+            }]);
+        addMoreActions = more;
+    }
+    return {
+        name: basicInfo.name,
+        description: basicInfo.description || undefined,
+        trigger: basicInfo.trigger,
+        table: basicInfo.table,
+        condition: basicInfo.condition || 'true',
+        actions,
+        priority: basicInfo.priority || 10,
+        enabled: true
+    };
+}
+/**
+ * Interactive prompt for updating a rule
+ */
+async function promptForRuleUpdate(appId, currentRule) {
+    const schemaResult = await api.getSchema(appId);
+    const tables = schemaResult.data || [];
+    const tableChoices = [
+        { name: '* (All tables)', value: '*' },
+        ...tables.map((t) => ({ name: `${t.icon || ''} ${t.name} (${t.slug})`, value: t.slug }))
+    ];
+    const updates = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Rule name:',
+            default: currentRule.name
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description:',
+            default: currentRule.description || ''
+        },
+        {
+            type: 'list',
+            name: 'trigger',
+            message: 'Trigger:',
+            choices: TRIGGERS,
+            default: currentRule.trigger
+        },
+        {
+            type: 'list',
+            name: 'table',
+            message: 'Table:',
+            choices: tableChoices,
+            default: currentRule.table
+        },
+        {
+            type: 'input',
+            name: 'condition',
+            message: 'Condition:',
+            default: currentRule.condition || 'true'
+        },
+        {
+            type: 'number',
+            name: 'priority',
+            message: 'Priority:',
+            default: currentRule.priority || 10
+        },
+        {
+            type: 'confirm',
+            name: 'enabled',
+            message: 'Enabled?',
+            default: currentRule.enabled !== false
+        },
+        {
+            type: 'confirm',
+            name: 'updateActions',
+            message: 'Update actions?',
+            default: false
+        }
+    ]);
+    const result = {
+        name: updates.name,
+        description: updates.description || undefined,
+        trigger: updates.trigger,
+        table: updates.table,
+        condition: updates.condition,
+        priority: updates.priority,
+        enabled: updates.enabled
+    };
+    if (updates.updateActions) {
+        const actions = [];
+        let addMoreActions = true;
+        console.log();
+        console.log(chalk_1.default.cyan('Enter new actions (this will replace existing actions):'));
+        console.log();
+        while (addMoreActions) {
+            const action = await promptForAction(appId, tables);
+            actions.push(action);
+            const { more } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'more',
+                    message: 'Add another action?',
+                    default: false
+                }]);
+            addMoreActions = more;
+        }
+        result.actions = actions;
+    }
+    return result;
+}
+/**
+ * Interactive prompt for a single action
+ */
+async function promptForAction(appId, tables) {
+    const { actionType } = await inquirer_1.default.prompt([{
+            type: 'list',
+            name: 'actionType',
+            message: 'Action type:',
+            choices: ACTION_TYPES
+        }]);
+    switch (actionType) {
+        case 'set_field': {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'field',
+                    message: 'Field name to set:',
+                    validate: (input) => input.trim() ? true : 'Field name is required'
+                },
+                {
+                    type: 'input',
+                    name: 'value',
+                    message: 'Value (can use Liquid: {{ user.id }}):',
+                    validate: (input) => input.trim() ? true : 'Value is required'
+                }
+            ]);
+            return { type: 'set_field', field: answers.field, value: answers.value };
+        }
+        case 'calculate': {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'field',
+                    message: 'Field name to calculate:',
+                    validate: (input) => input.trim() ? true : 'Field name is required'
+                },
+                {
+                    type: 'input',
+                    name: 'value',
+                    message: 'Formula (Liquid: {{ price | times: quantity }}):',
+                    validate: (input) => input.trim() ? true : 'Formula is required'
+                }
+            ]);
+            return { type: 'calculate', field: answers.field, value: answers.value };
+        }
+        case 'reject': {
+            const answers = await inquirer_1.default.prompt([{
+                    type: 'input',
+                    name: 'message',
+                    message: 'Error message (can use Liquid):',
+                    validate: (input) => input.trim() ? true : 'Message is required'
+                }]);
+            return { type: 'reject', message: answers.message };
+        }
+        case 'validate': {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'condition',
+                    message: 'Validation condition (Liquid, should output "true" when valid):',
+                    validate: (input) => input.trim() ? true : 'Condition is required'
+                },
+                {
+                    type: 'input',
+                    name: 'message',
+                    message: 'Error message if validation fails:',
+                    validate: (input) => input.trim() ? true : 'Message is required'
+                }
+            ]);
+            return { type: 'validate', condition: answers.condition, message: answers.message };
+        }
+        case 'lookup_and_set': {
+            const tableChoices = tables.map((t) => ({
+                name: `${t.icon || ''} ${t.name} (${t.slug})`,
+                value: t.slug
+            }));
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'field',
+                    message: 'Field to populate:',
+                    validate: (input) => input.trim() ? true : 'Field is required'
+                },
+                {
+                    type: 'list',
+                    name: 'lookupTable',
+                    message: 'Table to query:',
+                    choices: tableChoices
+                },
+                {
+                    type: 'input',
+                    name: 'lookupFilter',
+                    message: 'Filter (JSON, e.g., {"location": "{{ location }}"}):',
+                    default: '{}'
+                },
+                {
+                    type: 'list',
+                    name: 'selectBy',
+                    message: 'How to select from multiple matches:',
+                    choices: LOOKUP_SELECT_OPTIONS
+                },
+                {
+                    type: 'input',
+                    name: 'selectField',
+                    message: 'Field for min/max selection (if applicable):',
+                    when: (ans) => ans.selectBy === 'min' || ans.selectBy === 'max'
+                },
+                {
+                    type: 'input',
+                    name: 'returnField',
+                    message: 'Field to return from matched record:',
+                    default: 'id'
+                },
+                {
+                    type: 'list',
+                    name: 'noMatchAction',
+                    message: 'What to do if no match found:',
+                    choices: NO_MATCH_OPTIONS
+                },
+                {
+                    type: 'input',
+                    name: 'defaultValue',
+                    message: 'Default value:',
+                    when: (ans) => ans.noMatchAction === 'default'
+                },
+                {
+                    type: 'input',
+                    name: 'noMatchMessage',
+                    message: 'Error message if rejected:',
+                    when: (ans) => ans.noMatchAction === 'reject'
+                }
+            ]);
+            let lookupFilter = {};
+            try {
+                lookupFilter = JSON.parse(answers.lookupFilter || '{}');
+            }
+            catch {
+                // Keep empty object
+            }
+            return {
+                type: 'lookup_and_set',
+                field: answers.field,
+                lookupTable: answers.lookupTable,
+                lookupFilter,
+                selectBy: answers.selectBy,
+                selectField: answers.selectField,
+                returnField: answers.returnField,
+                noMatchAction: answers.noMatchAction,
+                defaultValue: answers.defaultValue,
+                noMatchMessage: answers.noMatchMessage
+            };
+        }
+        default:
+            return { type: 'set_field', field: '', value: '' };
+    }
+}
+function handleError(error) {
+    const errorLower = error.toLowerCase();
+    if (errorLower.includes('session expired') ||
+        errorLower.includes('token expired') ||
+        errorLower.includes('unauthorized')) {
+        config.clearAuth();
+        logger.error('Session expired. Credentials cleared.');
+        logger.info('Run: thinksoft login');
+        return;
+    }
+    if (errorLower.includes('not found')) {
+        logger.error('Agent or rule not found');
+        logger.info('Use "thinksoft agents" to list available agents');
+        return;
+    }
+    logger.error(error);
+}
+//# sourceMappingURL=rules.js.map