checkbox-cli 3.0.0 → 3.1.0

package/dist/checkbox.js

@@ -16,7 +16,7 @@ import { join } from 'path';
 // ── Config ──────────────────────────────────────────────────────────
 const CONFIG_DIR = join(homedir(), '.checkbox');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-const VERSION = '3.0.0';
+const VERSION = '3.1.0';
 function loadConfig() {
     try {
         if (!existsSync(CONFIG_FILE))
@@ -56,7 +56,7 @@ function resolveConfig() {
 // ── API ─────────────────────────────────────────────────────────────
 function extractError(obj) {
     if (!obj)
-        return 'Unknown error';
+        return '';
     if (typeof obj === 'string')
         return obj;
     if (typeof obj.error === 'string')
@@ -78,46 +78,78 @@ function api(cfg) {
             headers,
             body: JSON.stringify(body),
         });
-        const json = await res.json().catch(() => null);
-        if (!res.ok)
-            throw new Error(extractError(json) || `Request failed (${res.status})`);
-        if (json && json.success === false)
+        const text = await res.text().catch(() => '');
+        let json = null;
+        try {
+            json = JSON.parse(text);
+        }
+        catch { }
+        if (!res.ok) {
+            throw new Error(extractError(json) || text || `Request failed (${res.status})`);
+        }
+        if (json && json.success === false) {
             throw new Error(extractError(json) || 'Request failed');
+        }
         return json;
     }
     async function get(path) {
         const res = await fetch(`${cfg.apiUrl}${path}`, { headers });
-        const json = await res.json().catch(() => null);
-        if (!res.ok)
-            throw new Error(extractError(json) || `Request failed (${res.status})`);
-        if (json && json.success === false)
+        const text = await res.text().catch(() => '');
+        let json = null;
+        try {
+            json = JSON.parse(text);
+        }
+        catch { }
+        if (!res.ok) {
+            throw new Error(extractError(json) || text || `Request failed (${res.status})`);
+        }
+        if (json && json.success === false) {
             throw new Error(extractError(json) || 'Request failed');
+        }
         return json;
     }
     return { post, get };
 }
 // ── Data Helpers ────────────────────────────────────────────────────
 async function listEntities(post, orgId, entityType, filters) {
-    const res = await post('/api/v2/query', {
-        type: 'list_entities',
-        organization_id: orgId,
-        payload: { entity_type: entityType, organization_id: orgId, ...filters },
-    });
-    return Array.isArray(res.data) ? res.data : [];
+    try {
+        const res = await post('/api/v2/query', {
+            type: 'list_entities',
+            organization_id: orgId,
+            payload: { entity_type: entityType, organization_id: orgId, ...filters },
+        });
+        return Array.isArray(res.data) ? res.data : [];
+    }
+    catch (err) {
+        p.log.error(err.message || `Could not load ${entityType}`);
+        return [];
+    }
 }
 async function searchEntities(post, orgId, search, limit = 20) {
-    const res = await post('/api/v2/introspection/entities', {
-        organization_id: orgId,
-        search,
-        limit,
-    });
-    return res.data?.entities || [];
+    try {
+        const res = await post('/api/v2/introspection/entities', {
+            organization_id: orgId,
+            search,
+            limit,
+        });
+        return res.data?.entities || [];
+    }
+    catch (err) {
+        p.log.error(err.message || 'Search failed');
+        return [];
+    }
 }
 async function getWorkspaceNodes(post, orgId) {
-    const res = await post('/api/v2/introspection/workspace', {
-        organization_id: orgId,
-    });
-    return res.data?.nodes || [];
+    try {
+        const res = await post('/api/v2/introspection/workspace', {
+            organization_id: orgId,
+        });
+        return res.data?.nodes || [];
+    }
+    catch (err) {
+        p.log.error(err.message || 'Could not load workspace');
+        return [];
+    }
 }
 // ── Formatters ──────────────────────────────────────────────────────
 function truncate(s, max) {
@@ -448,40 +480,149 @@ async function mTasks(cfg, post) {
             if (!frequency)
                 return mTasks(cfg, post);
             const payload = { name, frequency };
+            // Frequency configuration (day of week, day of month, etc.)
+            if (frequency === 'weekly') {
+                const dow = await sel('Which day of the week?', [
+                    { value: 'monday', label: 'Monday' }, { value: 'tuesday', label: 'Tuesday' },
+                    { value: 'wednesday', label: 'Wednesday' }, { value: 'thursday', label: 'Thursday' },
+                    { value: 'friday', label: 'Friday' }, { value: 'saturday', label: 'Saturday' },
+                    { value: 'sunday', label: 'Sunday' },
+                ]);
+                if (dow)
+                    payload.frequency_config = { day_of_week: dow };
+            }
+            else if (frequency === 'monthly') {
+                const dom = await txt('Which day of the month? (1-31)', false, '1');
+                if (dom)
+                    payload.frequency_config = { day_of_month: parseInt(dom, 10) };
+            }
+            else if (frequency === 'yearly') {
+                const month = await txt('Month (1-12)', false, '1');
+                const day = await txt('Day (1-31)', false, '1');
+                if (month && day)
+                    payload.frequency_config = { month: parseInt(month, 10), day: parseInt(day, 10) };
+            }
             const addPlan = await yn('Add to a plan?');
             if (addPlan) {
                 const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
-                if (plan)
+                if (plan) {
                     payload.plan_id = plan.id;
+                    // Optionally link to a specific requirement
+                    const linkReq = await yn('Link to a specific requirement?');
+                    if (linkReq) {
+                        const req = await pickEntity(post, cfg.orgId, 'requirement', 'requirements');
+                        if (req)
+                            payload.requirement_id = req.id;
+                    }
+                }
             }
-            const more = await yn('Add more details? (description, time, reminders, etc.)');
-            if (more) {
-                const desc = await txt('Description');
-                if (desc)
-                    payload.description = desc;
-                const priv = await yn('Private task?');
-                if (priv)
-                    payload.is_private = true;
-                const time = await txt('Scheduled time (HH:MM)', false, '09:00');
-                if (time)
-                    payload.time = time;
-                const reminder = await sel('Reminder', [
-                    { value: 'none', label: 'No reminder' },
-                    { value: 'notification', label: 'Push notification' },
-                    { value: 'email', label: 'Email' },
-                ]);
-                if (reminder && reminder !== 'none') {
-                    payload.reminder_mode = reminder;
-                    const mins = await txt('Minutes before', false, '30');
-                    if (mins)
-                        payload.reminder_minutes = parseInt(mins, 10);
+            // Description
+            const desc = await txt('Description (blank to skip)');
+            if (desc)
+                payload.description = desc;
+            // Time
+            const time = await txt('Scheduled time (HH:MM, blank to skip)', false, '09:00');
+            if (time)
+                payload.time = time;
+            // Assignment
+            const assign = await yn('Assign to a specific person?');
+            if (assign) {
+                const assignId = await txt('User ID to assign to', true);
+                if (assignId) {
+                    payload.assigned_to = assignId;
+                    const assignName = await txt('Their display name (optional)');
+                    if (assignName)
+                        payload.assigned_to_name = assignName;
+                }
+            }
+            // Privacy
+            const priv = await yn('Private task?');
+            if (priv)
+                payload.is_private = true;
+            // Reminder
+            const reminder = await sel('Reminder', [
+                { value: 'none', label: 'No reminder' },
+                { value: 'notification', label: 'Push notification' },
+                { value: 'email', label: 'Email' },
+            ]);
+            if (reminder && reminder !== 'none') {
+                payload.reminder_mode = reminder;
+                const mins = await txt('Minutes before', false, '30');
+                if (mins)
+                    payload.reminder_minutes = parseInt(mins, 10);
+            }
+            // Conditional question
+            const cond = await txt('Conditional question (blank to skip)', false, 'e.g. Is the equipment available?');
+            if (cond)
+                payload.conditional_question = cond;
+            // Approval requirement
+            const approval = await yn('Requires approval before completion?');
+            if (approval)
+                payload.approval_required = true;
+            // Proof / Validation requirements (THE MOST IMPORTANT FEATURE)
+            const addProof = await yn('Require proof to complete this task? (photos, documents, location, etc.)');
+            if (addProof) {
+                const validationTypes = [];
+                let addMoreProof = true;
+                while (addMoreProof) {
+                    const proofType = await sel('What type of proof?', [
+                        { value: 'photo', label: 'Photo', hint: 'require a photo to be taken' },
+                        { value: 'document', label: 'Document', hint: 'require a document upload' },
+                        { value: 'geolocation', label: 'Location check-in', hint: 'require being at a specific location' },
+                        { value: 'checklist', label: 'Checklist', hint: 'require completing a checklist' },
+                        { value: 'table', label: 'Table record', hint: 'require filling out a data table' },
+                    ]);
+                    if (!proofType)
+                        break;
+                    const vt = { type: proofType };
+                    // Pick the specific asset for this proof type
+                    if (proofType === 'photo') {
+                        const ph = await pickEntity(post, cfg.orgId, 'photo', 'photo assets');
+                        if (ph)
+                            vt.config_id = ph.id;
+                    }
+                    else if (proofType === 'document') {
+                        const doc = await pickEntity(post, cfg.orgId, 'document', 'document folders');
+                        if (doc) {
+                            vt.config_id = doc.id;
+                            const targetMode = await sel('Where should uploads go?', [
+                                { value: 'locked', label: 'Always to this folder' },
+                                { value: 'user_choice', label: 'Let user choose folder' },
+                            ]);
+                            if (targetMode) {
+                                vt.target_mode = targetMode;
+                                if (targetMode === 'locked')
+                                    vt.target_folder_id = doc.id;
+                            }
+                        }
+                    }
+                    else if (proofType === 'geolocation') {
+                        const area = await pickEntity(post, cfg.orgId, 'geolocation_area', 'location areas');
+                        if (area)
+                            vt.config_id = area.id;
+                    }
+                    else if (proofType === 'checklist') {
+                        const cl = await pickEntity(post, cfg.orgId, 'checklist', 'checklists');
+                        if (cl)
+                            vt.config_id = cl.id;
+                    }
+                    else if (proofType === 'table') {
+                        const tbl = await pickEntity(post, cfg.orgId, 'table', 'tables');
+                        if (tbl)
+                            vt.config_id = tbl.id;
+                    }
+                    validationTypes.push(vt);
+                    addMoreProof = !!(await yn('Add another proof requirement?'));
                 }
-                const approval = await yn('Requires approval?');
-                if (approval)
-                    payload.approval_required = true;
-                const cond = await txt('Conditional question (blank to skip)', false, 'e.g. Is the equipment available?');
-                if (cond)
-                    payload.conditional_question = cond;
+                if (validationTypes.length > 0)
+                    payload.validation_types = validationTypes;
+            }
+            // Share with specific users
+            const share = await yn('Share with specific users?');
+            if (share) {
+                const ids = await txt('User IDs (comma-separated)', true);
+                if (ids)
+                    payload.shared_with_ids = ids.split(',').map(s => s.trim()).filter(Boolean);
             }
             await cmd(post, cfg.orgId, 'create_task', payload, 'Creating task...');
             return mTasks(cfg, post);
@@ -490,24 +631,126 @@ async function mTasks(cfg, post) {
             const t = await pickEntity(post, cfg.orgId, 'task', 'tasks');
             if (!t)
                 return mTasks(cfg, post);
-            p.log.info(`Editing: ${pc.cyan(t.name)} ${pc.dim('(leave blank to skip)')}`);
-            const updates = {};
-            const n = await txt('New name');
-            if (n === null)
-                return mTasks(cfg, post);
-            if (n)
-                updates.name = n;
-            const f = await sel('New frequency', [
-                { value: '__skip', label: pc.dim('Keep current') },
-                { value: 'daily', label: 'Daily' }, { value: 'weekly', label: 'Weekly' },
-                { value: 'monthly', label: 'Monthly' }, { value: 'yearly', label: 'Yearly' },
-                { value: 'one-time', label: 'One time' },
+            p.log.info(`Editing: ${pc.cyan(t.name)}`);
+            const field = await sel('What would you like to change?', [
+                { value: 'name', label: 'Name' },
+                { value: 'frequency', label: 'Frequency' },
+                { value: 'description', label: 'Description' },
+                { value: 'time', label: 'Scheduled time' },
+                { value: 'assigned_to', label: 'Assignment' },
+                { value: 'is_private', label: 'Privacy' },
+                { value: 'reminder', label: 'Reminder settings' },
+                { value: 'conditional_question', label: 'Conditional question' },
+                { value: 'plan', label: 'Plan / requirement link' },
+                { value: '__back', label: pc.dim('\u2190 Back') },
             ]);
-            if (f && f !== '__skip')
-                updates.frequency = f;
-            const d = await txt('New description');
-            if (d)
-                updates.description = d;
+            if (!field || field === '__back')
+                return mTasks(cfg, post);
+            const updates = {};
+            switch (field) {
+                case 'name': {
+                    const n = await txt('New name', true);
+                    if (n)
+                        updates.name = n;
+                    break;
+                }
+                case 'frequency': {
+                    const f = await sel('New frequency', [
+                        { value: 'daily', label: 'Daily' }, { value: 'weekly', label: 'Weekly' },
+                        { value: 'monthly', label: 'Monthly' }, { value: 'yearly', label: 'Yearly' },
+                        { value: 'one-time', label: 'One time' },
+                    ]);
+                    if (f) {
+                        updates.frequency = f;
+                        if (f === 'weekly') {
+                            const dow = await sel('Which day?', [
+                                { value: 'monday', label: 'Monday' }, { value: 'tuesday', label: 'Tuesday' },
+                                { value: 'wednesday', label: 'Wednesday' }, { value: 'thursday', label: 'Thursday' },
+                                { value: 'friday', label: 'Friday' }, { value: 'saturday', label: 'Saturday' },
+                                { value: 'sunday', label: 'Sunday' },
+                            ]);
+                            if (dow)
+                                updates.frequency_config = { day_of_week: dow };
+                        }
+                        else if (f === 'monthly') {
+                            const dom = await txt('Which day of the month? (1-31)', false, '1');
+                            if (dom)
+                                updates.frequency_config = { day_of_month: parseInt(dom, 10) };
+                        }
+                    }
+                    break;
+                }
+                case 'description': {
+                    const d = await txt('New description', true);
+                    if (d)
+                        updates.description = d;
+                    break;
+                }
+                case 'time': {
+                    const time = await txt('New scheduled time (HH:MM)', false, '09:00');
+                    if (time)
+                        updates.time = time;
+                    break;
+                }
+                case 'assigned_to': {
+                    const aid = await txt('User ID to assign to (blank to unassign)');
+                    updates.assigned_to = aid || null;
+                    if (aid) {
+                        const aname = await txt('Their display name (optional)');
+                        if (aname)
+                            updates.assigned_to_name = aname;
+                    }
+                    break;
+                }
+                case 'is_private': {
+                    const priv = await yn('Make this task private?');
+                    updates.is_private = !!priv;
+                    break;
+                }
+                case 'reminder': {
+                    const mode = await sel('Reminder type', [
+                        { value: 'none', label: 'No reminder' },
+                        { value: 'notification', label: 'Push notification' },
+                        { value: 'email', label: 'Email' },
+                    ]);
+                    if (mode === 'none') {
+                        updates.reminder_mode = null;
+                        updates.reminder_minutes = null;
+                    }
+                    else if (mode) {
+                        updates.reminder_mode = mode;
+                        const mins = await txt('Minutes before', false, '30');
+                        if (mins)
+                            updates.reminder_minutes = parseInt(mins, 10);
+                    }
+                    break;
+                }
+                case 'conditional_question': {
+                    const q = await txt('Conditional question (blank to remove)');
+                    updates.conditional_question = q || null;
+                    break;
+                }
+                case 'plan': {
+                    const plan = await pickEntity(post, cfg.orgId, 'plan', 'plans');
+                    if (plan) {
+                        updates.plan_id = plan.id;
+                        const linkReq = await yn('Link to a requirement?');
+                        if (linkReq) {
+                            const req = await pickEntity(post, cfg.orgId, 'requirement', 'requirements');
+                            if (req)
+                                updates.requirement_id = req.id;
+                        }
+                    }
+                    else {
+                        const unlink = await yn('Remove from current plan?');
+                        if (unlink) {
+                            updates.plan_id = null;
+                            updates.requirement_id = null;
+                        }
+                    }
+                    break;
+                }
+            }
             if (Object.keys(updates).length > 0) {
                 await cmd(post, cfg.orgId, 'update_task', { task_id: t.id, updates }, 'Updating...');
             }
@@ -977,14 +1220,67 @@ async function mTables(cfg, post) {
                 if (!fn)
                     break;
                 const ft = await sel('Column type', [
-                    { value: 'text', label: 'Text' }, { value: 'number', label: 'Number' },
-                    { value: 'date', label: 'Date' }, { value: 'select', label: 'Dropdown' },
-                    { value: 'checkbox', label: 'Checkbox' }, { value: 'file', label: 'File' },
+                    { value: 'text', label: 'Text' },
+                    { value: 'number', label: 'Number' },
+                    { value: 'date', label: 'Date' },
+                    { value: 'select', label: 'Dropdown', hint: 'pick from a list of values' },
+                    { value: 'multi_select', label: 'Multi-select dropdown', hint: 'pick multiple values' },
+                    { value: 'checkbox', label: 'Checkbox', hint: 'yes/no toggle' },
+                    { value: 'file', label: 'File upload' },
+                    { value: 'url', label: 'URL / link' },
+                    { value: 'email', label: 'Email address' },
+                    { value: 'phone', label: 'Phone number' },
+                    { value: 'currency', label: 'Currency / money' },
+                    { value: 'percent', label: 'Percentage' },
+                    { value: 'rating', label: 'Rating (1-5)' },
+                    { value: 'relation', label: 'Link to another table' },
                 ]);
                 if (!ft)
                     break;
+                const col = { name: fn, type: ft };
                 const req = await yn('Required?');
-                fields.push({ name: fn, type: ft, ...(req ? { required: true } : {}) });
+                if (req)
+                    col.required = true;
+                // Dropdown values
+                if (ft === 'select' || ft === 'multi_select') {
+                    const optSource = await sel('Where do the options come from?', [
+                        { value: 'manual', label: 'I\'ll type them now' },
+                        { value: 'list', label: 'Link to an existing table/list' },
+                    ]);
+                    if (optSource === 'manual') {
+                        const optStr = await txt('Options (comma-separated)', true, 'e.g. Pass, Fail, N/A');
+                        if (optStr)
+                            col.options = optStr.split(',').map(s => s.trim()).filter(Boolean);
+                    }
+                    else if (optSource === 'list') {
+                        const srcTable = await pickEntity(post, cfg.orgId, 'table', 'tables');
+                        if (srcTable) {
+                            col.source_table_id = srcTable.id;
+                            const srcField = await txt('Which column to use as the option label?', false, 'name');
+                            if (srcField)
+                                col.source_field = srcField;
+                        }
+                    }
+                    const defaultVal = await txt('Default value (blank for none)');
+                    if (defaultVal)
+                        col.default = defaultVal;
+                }
+                // Number/currency constraints
+                if (ft === 'number' || ft === 'currency' || ft === 'percent') {
+                    const min = await txt('Minimum value (blank for no limit)');
+                    if (min)
+                        col.min = parseFloat(min);
+                    const max = await txt('Maximum value (blank for no limit)');
+                    if (max)
+                        col.max = parseFloat(max);
+                }
+                // Relation target
+                if (ft === 'relation') {
+                    const relTable = await pickEntity(post, cfg.orgId, 'table', 'tables');
+                    if (relTable)
+                        col.relation_table_id = relTable.id;
+                }
+                fields.push(col);
                 addMore = !!(await yn('Add another column?'));
             }
             if (fields.length > 0)
@@ -1478,20 +1774,37 @@ async function mAutomation(cfg, post) {
             return mAutomation(cfg, post);
         }
         case 'val-create': {
-            const task = await pickEntity(post, cfg.orgId, 'task', 'tasks');
-            if (!task)
+            // Choose target: task or requirement
+            const target = await sel('Apply this rule to', [
+                { value: 'task', label: 'A specific task' },
+                { value: 'requirement', label: 'A requirement', hint: 'applies to all tasks under it' },
+            ]);
+            if (!target)
                 return mAutomation(cfg, post);
+            const rulePayload = {};
+            if (target === 'task') {
+                const task = await pickEntity(post, cfg.orgId, 'task', 'tasks');
+                if (!task)
+                    return mAutomation(cfg, post);
+                rulePayload.task_id = task.id;
+            }
+            else {
+                const req = await pickEntity(post, cfg.orgId, 'requirement', 'requirements');
+                if (!req)
+                    return mAutomation(cfg, post);
+                rulePayload.requirement_id = req.id;
+            }
             const name = await txt('Rule name', true, 'e.g. Require photo proof');
             if (!name)
                 return mAutomation(cfg, post);
             const ruleType = await sel('Rule type', [
-                { value: 'proof_required', label: 'Proof required', hint: 'photo, document, location, etc.' },
-                { value: 'field_constraint', label: 'Field constraint', hint: 'validate a data field' },
+                { value: 'proof_required', label: 'Proof required', hint: 'photo, document, location, checklist, or table' },
+                { value: 'field_constraint', label: 'Field constraint', hint: 'validate a specific field value' },
+                { value: 'cross_field', label: 'Cross-field validation', hint: 'compare two fields' },
+                { value: 'aggregate', label: 'Aggregate check', hint: 'count/sum/avg of historical data' },
                 { value: 'approval_required', label: 'Approval required', hint: 'needs manager sign-off' },
                 { value: 'time_window', label: 'Time window', hint: 'must be done within a time range' },
-                { value: 'record_exists', label: 'Record exists', hint: 'verify data was entered' },
-                { value: 'cross_field', label: 'Cross-field validation' },
-                { value: 'aggregate', label: 'Aggregate check' },
+                { value: 'record_exists', label: 'Record exists', hint: 'verify a table record was created' },
             ]);
             if (!ruleType)
                 return mAutomation(cfg, post);
@@ -1499,21 +1812,201 @@ async function mAutomation(cfg, post) {
             if (ruleType === 'proof_required') {
                 const proofType = await sel('What kind of proof?', [
                     { value: 'photo', label: 'Photo' }, { value: 'document', label: 'Document' },
-                    { value: 'geolocation', label: 'Location' }, { value: 'checklist', label: 'Checklist' },
+                    { value: 'geolocation', label: 'Location check-in' }, { value: 'checklist', label: 'Checklist' },
+                    { value: 'table', label: 'Table record' },
+                ]);
+                if (proofType) {
+                    condition.validation_type = proofType;
+                    // Let them pick the specific asset
+                    if (proofType === 'photo') {
+                        const ph = await pickEntity(post, cfg.orgId, 'photo', 'photo assets');
+                        if (ph)
+                            condition.config_id = ph.id;
+                    }
+                    else if (proofType === 'document') {
+                        const doc = await pickEntity(post, cfg.orgId, 'document', 'document folders');
+                        if (doc) {
+                            condition.config_id = doc.id;
+                            const tMode = await sel('Upload destination', [
+                                { value: 'locked', label: 'Always to this folder' },
+                                { value: 'user_choice', label: 'Let user choose' },
+                            ]);
+                            if (tMode) {
+                                condition.target_mode = tMode;
+                                if (tMode === 'locked')
+                                    condition.target_folder_id = doc.id;
+                            }
+                        }
+                    }
+                    else if (proofType === 'geolocation') {
+                        const area = await pickEntity(post, cfg.orgId, 'geolocation_area', 'location areas');
+                        if (area)
+                            condition.config_id = area.id;
+                    }
+                    else if (proofType === 'checklist') {
+                        const cl = await pickEntity(post, cfg.orgId, 'checklist', 'checklists');
+                        if (cl)
+                            condition.config_id = cl.id;
+                    }
+                    else if (proofType === 'table') {
+                        const tbl = await pickEntity(post, cfg.orgId, 'table', 'tables');
+                        if (tbl)
+                            condition.config_id = tbl.id;
+                    }
+                }
+            }
+            else if (ruleType === 'field_constraint') {
+                const field = await txt('Field name', true, 'e.g. status, temperature, score');
+                if (field)
+                    condition.field = field;
+                const op = await sel('Condition', [
+                    { value: 'eq', label: 'Equals' }, { value: 'neq', label: 'Not equals' },
+                    { value: 'gt', label: 'Greater than' }, { value: 'gte', label: 'Greater than or equal' },
+                    { value: 'lt', label: 'Less than' }, { value: 'lte', label: 'Less than or equal' },
+                    { value: 'in', label: 'Is one of (list)' }, { value: 'not_in', label: 'Is not one of (list)' },
+                    { value: 'is_null', label: 'Is empty' }, { value: 'is_not_null', label: 'Is not empty' },
+                    { value: 'matches', label: 'Matches pattern' },
+                ]);
+                if (op)
+                    condition.operator = op;
+                if (op && !['is_null', 'is_not_null'].includes(op)) {
+                    if (op === 'in' || op === 'not_in') {
+                        const vals = await txt('Values (comma-separated)', true);
+                        if (vals)
+                            condition.value = vals.split(',').map(s => s.trim());
+                    }
+                    else {
+                        const val = await txt('Value', true);
+                        if (val)
+                            condition.value = isNaN(Number(val)) ? val : Number(val);
+                    }
+                }
+            }
+            else if (ruleType === 'cross_field') {
+                const f1 = await txt('First field', true);
+                if (f1)
+                    condition.field = f1;
+                const cop = await sel('Must be', [
+                    { value: 'eq', label: 'Equal to' }, { value: 'neq', label: 'Not equal to' },
+                    { value: 'gt', label: 'Greater than' }, { value: 'gte', label: 'Greater or equal to' },
+                    { value: 'lt', label: 'Less than' }, { value: 'lte', label: 'Less or equal to' },
+                ]);
+                if (cop)
+                    condition.compare_operator = cop;
+                const f2 = await txt('Second field', true);
+                if (f2)
+                    condition.compare_field = f2;
+            }
+            else if (ruleType === 'aggregate') {
+                const aggFn = await sel('Aggregate function', [
+                    { value: 'count', label: 'Count' }, { value: 'sum', label: 'Sum' },
+                    { value: 'avg', label: 'Average' }, { value: 'min', label: 'Minimum' },
+                    { value: 'max', label: 'Maximum' },
+                ]);
+                if (aggFn)
+                    condition.aggregate_function = aggFn;
+                condition.aggregate_table = 'task_history';
+                if (aggFn !== 'count') {
+                    const aggField = await txt('Field to aggregate', true);
+                    if (aggField)
+                        condition.aggregate_field = aggField;
+                }
+                const aggOp = await sel('Result must be', [
+                    { value: 'eq', label: 'Equal to' }, { value: 'gt', label: 'Greater than' },
+                    { value: 'gte', label: 'At least' }, { value: 'lt', label: 'Less than' },
+                    { value: 'lte', label: 'At most' },
                 ]);
-                if (proofType)
-                    condition.proof_type = proofType;
+                if (aggOp)
+                    condition.aggregate_operator = aggOp;
+                const aggVal = await txt('Target value', true, 'e.g. 5');
+                if (aggVal)
+                    condition.aggregate_value = parseFloat(aggVal);
+            }
+            else if (ruleType === 'approval_required') {
+                const approverType = await sel('Who must approve?', [
+                    { value: 'role', label: 'Anyone with a specific role' },
+                    { value: 'user', label: 'A specific person' },
+                ]);
+                if (approverType === 'role') {
+                    const role = await sel('Required role', [
+                        { value: 'admin', label: 'Admin' }, { value: 'super_admin', label: 'Super Admin' },
+                    ]);
+                    if (role)
+                        condition.approval_approver_role = role;
+                }
+                else if (approverType === 'user') {
+                    const uid = await txt('Approver user ID', true);
+                    if (uid)
+                        condition.approval_approver_id = uid;
+                }
             }
             else if (ruleType === 'time_window') {
-                const start = await txt('Start time (HH:MM)', false, '08:00');
-                const end = await txt('End time (HH:MM)', false, '17:00');
+                const wType = await sel('Window type', [
+                    { value: 'daily', label: 'Daily time window' },
+                    { value: 'custom', label: 'Custom date/time range' },
+                ]);
+                if (wType)
+                    condition.window_type = wType;
+                const start = await txt('Start time (HH:MM)', true, '08:00');
                 if (start)
                     condition.start_time = start;
+                const end = await txt('End time (HH:MM)', true, '17:00');
                 if (end)
                     condition.end_time = end;
+                const tz = await txt('Timezone (blank for UTC)', false, 'America/New_York');
+                if (tz)
+                    condition.timezone = tz;
+            }
+            else if (ruleType === 'record_exists') {
+                const tbl = await pickEntity(post, cfg.orgId, 'table', 'tables');
+                if (tbl) {
+                    condition.table = tbl.id;
+                    const addFilters = await yn('Add filters? (only match records with specific values)');
+                    if (addFilters) {
+                        const filters = [];
+                        let addF = true;
+                        while (addF) {
+                            const ff = await txt('Field name', true);
+                            if (!ff)
+                                break;
+                            const fop = await sel('Condition', [
+                                { value: 'eq', label: 'Equals' }, { value: 'neq', label: 'Not equals' },
+                                { value: 'gt', label: 'Greater than' }, { value: 'lt', label: 'Less than' },
+                                { value: 'is_not_null', label: 'Has a value' },
+                            ]);
+                            if (!fop)
+                                break;
+                            if (fop === 'is_not_null') {
+                                filters.push({ field: ff, operator: fop, value: null });
+                            }
+                            else {
+                                const fv = await txt('Value', true);
+                                if (fv)
+                                    filters.push({ field: ff, operator: fop, value: isNaN(Number(fv)) ? fv : Number(fv) });
+                            }
+                            addF = !!(await yn('Add another filter?'));
+                        }
+                        if (filters.length > 0)
+                            condition.filters = filters;
+                    }
+                }
+            }
+            // Grouping options
+            const addGroup = await yn('Add to a rule group? (for AND/OR logic with other rules)');
+            if (addGroup) {
+                const gid = await txt('Group ID (create a new UUID or use an existing group ID)', true);
+                if (gid) {
+                    rulePayload.group_id = gid;
+                    const gop = await sel('Group logic', [
+                        { value: 'AND', label: 'AND — all rules in the group must pass' },
+                        { value: 'OR', label: 'OR — any rule in the group can pass' },
+                    ]);
+                    if (gop)
+                        rulePayload.group_operator = gop;
+                }
             }
             await cmd(post, cfg.orgId, 'create_validation_rule', {
-                task_id: task.id, name, rule_type: ruleType, condition,
+                ...rulePayload, name, rule_type: ruleType, condition,
             }, 'Creating validation rule...');
             return mAutomation(cfg, post);
         }
@@ -1589,25 +2082,100 @@ async function mAutomation(cfg, post) {
             if (!name)
                 return mAutomation(cfg, post);
             const eventType = await sel('What triggers this?', [
-                { value: 'record_created', label: 'New record added to a table' },
-                { value: 'record_updated', label: 'Record updated in a table' },
                 { value: 'task_completed', label: 'Another task completed' },
-                { value: 'task_missed', label: 'A task was missed' },
-                { value: 'approval_resolved', label: 'An approval was resolved' },
+                { value: 'task_uncompleted', label: 'A task was reopened' },
+                { value: 'task_created', label: 'A new task was created' },
+                { value: 'task_updated', label: 'A task was updated' },
+                { value: 'validation_submitted', label: 'Proof was submitted' },
+                { value: 'approval_requested', label: 'An approval was requested' },
+                { value: 'approval_approved', label: 'An approval was granted' },
+                { value: 'approval_rejected', label: 'An approval was rejected' },
+                { value: 'table_record_created', label: 'New record added to a table' },
+                { value: 'conditional_answer', label: 'A conditional question was answered' },
+                { value: 'document_created', label: 'A document was uploaded' },
+                { value: 'checklist_created', label: 'A checklist was created' },
             ]);
             if (!eventType)
                 return mAutomation(cfg, post);
-            const sourceType = await sel('Source type', [
-                { value: 'table', label: 'Table' }, { value: 'task', label: 'Task' },
+            const sourceType = await sel('Source type (what entity fires the event)', [
+                { value: 'task', label: 'Task' },
+                { value: 'table', label: 'Table' },
+                { value: 'document', label: 'Document' },
+                { value: 'checklist', label: 'Checklist' },
+                { value: 'geolocation_area', label: 'Location area' },
                 { value: 'approval', label: 'Approval' },
+                { value: 'plan', label: 'Plan' },
             ]);
             if (!sourceType)
                 return mAutomation(cfg, post);
-            const payload = { task_id: task.id, name, event_type: eventType, source_entity_type: sourceType };
-            const source = await pickEntity(post, cfg.orgId, sourceType, `${sourceType}s`);
-            if (source)
-                payload.source_entity_id = source.id;
-            await cmd(post, cfg.orgId, 'create_trigger_rule', payload, 'Creating trigger rule...');
+            const trigPayload = { task_id: task.id, name, event_type: eventType, source_entity_type: sourceType };
+            const pickSource = await yn(`Pick a specific ${sourceType}? (or trigger on any)`);
+            if (pickSource) {
+                const source = await pickEntity(post, cfg.orgId, sourceType, `${sourceType}s`);
+                if (source)
+                    trigPayload.source_entity_id = source.id;
+            }
+            // Conditions
+            const addConds = await yn('Add conditions? (only trigger when specific criteria are met)');
+            if (addConds) {
+                const conditions = [];
+                let addC = true;
+                while (addC) {
+                    const cf = await txt('Field to check', true, 'e.g. status, frequency, name');
+                    if (!cf)
+                        break;
+                    const cop = await sel('Condition', [
+                        { value: 'eq', label: 'Equals' }, { value: 'neq', label: 'Not equals' },
+                        { value: 'gt', label: 'Greater than' }, { value: 'lt', label: 'Less than' },
+                        { value: 'in', label: 'Is one of' }, { value: 'is_not_null', label: 'Has a value' },
+                    ]);
+                    if (!cop)
+                        break;
+                    const csrc = await sel('Check against', [
+                        { value: 'payload', label: 'Event data (payload)' },
+                        { value: 'entity', label: 'Entity state' },
+                    ]);
+                    let cv = null;
+                    if (cop !== 'is_not_null') {
+                        if (cop === 'in') {
+                            const cvStr = await txt('Values (comma-separated)', true);
+                            if (cvStr)
+                                cv = cvStr.split(',').map(s => s.trim());
+                        }
+                        else {
+                            const cvTxt = await txt('Value', true);
+                            if (cvTxt)
+                                cv = isNaN(Number(cvTxt)) ? cvTxt : Number(cvTxt);
+                        }
+                    }
+                    conditions.push({ field: cf, operator: cop, value: cv, ...(csrc ? { source: csrc } : {}) });
+                    addC = !!(await yn('Add another condition?'));
+                }
+                if (conditions.length > 0) {
+                    trigPayload.conditions = conditions;
+                    if (conditions.length > 1) {
+                        const logic = await sel('Condition logic', [
+                            { value: 'AND', label: 'ALL conditions must be true' },
+                            { value: 'OR', label: 'ANY condition can be true' },
+                        ]);
+                        if (logic)
+                            trigPayload.condition_operator = logic;
+                    }
+                }
+            }
+            // Advanced options
+            const advanced = await yn('Configure advanced options? (frequency, message, debounce)');
+            if (advanced) {
+                const respect = await yn('Respect task frequency? (only activate on scheduled days)');
+                trigPayload.respect_frequency = !!respect;
+                const msg = await txt('Activation message (shown when triggered)');
+                if (msg)
+                    trigPayload.activation_message = msg;
+                const debounce = await txt('Debounce seconds (prevent re-triggering too fast)', false, '60');
+                if (debounce)
+                    trigPayload.debounce_seconds = parseInt(debounce, 10);
+            }
+            await cmd(post, cfg.orgId, 'create_trigger_rule', trigPayload, 'Creating trigger rule...');
             return mAutomation(cfg, post);
         }
         case 'trig-edit': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "checkbox-cli",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Beautiful, interactive CLI for Checkbox compliance management. Setup wizard, guided workflows, and full workspace control from your terminal.",
   "type": "module",
   "main": "dist/checkbox.js",