@phuetz/code-buddy 0.1.0 → 0.1.1

package/dist/scripting/builtins.js

@@ -1,7 +1,10 @@
 /**
- * Buddy Script Built-in Functions
+ * Unified Script Built-in Functions
  *
- * Provides bindings to code-buddy features for scripting
+ * Merged from FCS builtins (100+ functions, date/time, format, enumerate/zip)
+ * and Buddy Script builtins (ai.*, console.*, lazy agent loading, sandboxing)
+ *
+ * Extensions: .bs (primary), .fcs (backward-compatible alias)
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -13,15 +16,12 @@ let cachedAgent = null;
  * Get or create the AI agent for script execution
  */
 async function getOrCreateAgent(config) {
-    // Use provided agent if available
     if (config.agent) {
         return config.agent;
     }
-    // Return cached agent if already created
     if (cachedAgent) {
         return cachedAgent;
     }
-    // Try to create a new agent with lazy loading
     const apiKey = process.env.GROK_API_KEY;
     if (!apiKey) {
         logger.warn('GROK_API_KEY not set, AI operations will not be available');
@@ -40,12 +40,12 @@ async function getOrCreateAgent(config) {
     }
 }
 /**
- * Create all built-in functions for the Buddy Script runtime
+ * Create all built-in functions for the unified scripting runtime
  */
 export function createBuiltins(config, print) {
     const builtins = {};
     // ============================================
-    // Core Functions
+    // Core I/O
     // ============================================
     builtins.print = (...args) => {
         const message = args.map(a => stringify(a)).join(' ');
@@ -56,13 +56,47 @@ export function createBuiltins(config, print) {
         builtins.print(...args);
         return null;
     };
-    builtins.typeof = (value) => {
-        if (value === null)
-            return 'null';
+    builtins.input = async (prompt) => {
+        if (prompt)
+            print(prompt);
+        return '';
+    };
+    // ============================================
+    // Type Conversion
+    // ============================================
+    builtins.int = (value) => {
+        if (typeof value === 'string') {
+            if (value.startsWith('0x') || value.startsWith('0X')) {
+                return parseInt(value, 16);
+            }
+            if (value.startsWith('0b') || value.startsWith('0B')) {
+                return parseInt(value.substring(2), 2);
+            }
+            return parseInt(value, 10);
+        }
+        return Math.floor(Number(value));
+    };
+    builtins.float = (value) => parseFloat(String(value));
+    builtins.num = (value) => Number(value);
+    builtins.str = (value) => stringify(value);
+    builtins.bool = (value) => {
+        if (value === null || value === undefined || value === false || value === 0 || value === '') {
+            return false;
+        }
+        return true;
+    };
+    builtins.array = (value) => {
         if (Array.isArray(value))
-            return 'array';
-        return typeof value;
+            return value;
+        if (typeof value === 'string')
+            return value.split('');
+        if (typeof value === 'object' && value !== null)
+            return Object.values(value);
+        return [value];
     };
+    // ============================================
+    // Collection Functions
+    // ============================================
     builtins.len = (value) => {
         if (typeof value === 'string')
             return value.length;
@@ -72,81 +106,47 @@ export function createBuiltins(config, print) {
             return Object.keys(value).length;
         return 0;
     };
-    builtins.str = (value) => stringify(value);
-    builtins.num = (value) => Number(value);
-    builtins.bool = (value) => Boolean(value);
-    builtins.int = (value) => Math.floor(Number(value));
-    builtins.float = (value) => Number(value);
-    // ============================================
-    // Array/Object Functions
-    // ============================================
-    builtins.range = (start, end, step) => {
-        const s = Number(start);
-        const e = end !== undefined ? Number(end) : s;
-        const st = step !== undefined ? Number(step) : 1;
-        const actualStart = end !== undefined ? s : 0;
+    builtins.range = (...args) => {
+        let start = 0, end = 0, step = 1;
+        if (args.length === 1) {
+            end = args[0];
+        }
+        else if (args.length === 2) {
+            start = args[0];
+            end = args[1];
+        }
+        else if (args.length >= 3) {
+            start = args[0];
+            end = args[1];
+            step = args[2];
+        }
         const result = [];
-        if (st > 0) {
-            for (let i = actualStart; i < e; i += st)
+        if (step > 0) {
+            for (let i = start; i < end; i += step)
                 result.push(i);
         }
-        else if (st < 0) {
-            for (let i = actualStart; i > e; i += st)
+        else if (step < 0) {
+            for (let i = start; i > end; i += step)
                 result.push(i);
         }
         return result;
     };
-    builtins.keys = (obj) => {
-        if (typeof obj === 'object' && obj !== null) {
-            return Object.keys(obj);
-        }
-        return [];
-    };
-    builtins.values = (obj) => {
-        if (typeof obj === 'object' && obj !== null) {
-            return Object.values(obj);
-        }
-        return [];
-    };
-    builtins.entries = (obj) => {
-        if (typeof obj === 'object' && obj !== null) {
-            return Object.entries(obj);
-        }
-        return [];
-    };
-    builtins.push = (arr, ...items) => {
-        if (Array.isArray(arr)) {
-            arr.push(...items);
-            return arr; // Return array for chaining
-        }
-        throw new Error('push() requires an array as first argument. Got: ' + (typeof arr));
+    builtins.enumerate = (arr) => {
+        return arr.map((item, index) => [index, item]);
     };
-    builtins.pop = (arr) => {
-        if (Array.isArray(arr)) {
-            return arr.pop();
-        }
-        throw new Error('pop() requires an array as argument. Got: ' + (typeof arr));
-    };
-    builtins.join = (arr, separator) => {
-        if (Array.isArray(arr)) {
-            return arr.map(stringify).join(separator !== undefined ? String(separator) : ',');
-        }
-        throw new Error('join() requires an array as first argument. Got: ' + (typeof arr));
-    };
-    builtins.split = (str, separator) => {
-        return String(str).split(separator !== undefined ? String(separator) : '');
-    };
-    builtins.slice = (arr, start, end) => {
-        if (Array.isArray(arr) || typeof arr === 'string') {
-            return arr.slice(start !== undefined ? Number(start) : undefined, end !== undefined ? Number(end) : undefined);
+    builtins.zip = (...arrays) => {
+        const minLen = Math.min(...arrays.map(a => a.length));
+        const result = [];
+        for (let i = 0; i < minLen; i++) {
+            result.push(arrays.map(a => a[i]));
         }
-        throw new Error('slice() requires an array or string as first argument. Got: ' + (typeof arr));
+        return result;
     };
     builtins.map = async (arr, fn) => {
         if (!Array.isArray(arr))
-            throw new Error('map() requires an array as first argument. Got: ' + (typeof arr));
+            throw new Error('map() requires an array as first argument');
         if (typeof fn !== 'function')
-            throw new Error('map() requires a function as second argument. Got: ' + (typeof fn));
+            throw new Error('map() requires a function as second argument');
         const results = [];
         for (let i = 0; i < arr.length; i++) {
             results.push(await fn(arr[i], i));
@@ -155,29 +155,82 @@ export function createBuiltins(config, print) {
     };
     builtins.filter = async (arr, fn) => {
         if (!Array.isArray(arr))
-            throw new Error('filter() requires an array as first argument. Got: ' + (typeof arr));
+            throw new Error('filter() requires an array as first argument');
         if (typeof fn !== 'function')
-            throw new Error('filter() requires a function as second argument. Got: ' + (typeof fn));
+            throw new Error('filter() requires a function as second argument');
         const results = [];
         for (let i = 0; i < arr.length; i++) {
-            if (await fn(arr[i], i)) {
+            if (await fn(arr[i], i))
                 results.push(arr[i]);
-            }
         }
         return results;
     };
+    builtins.reduce = async (arr, fn, initial) => {
+        let acc = initial !== undefined ? initial : arr[0];
+        const startIdx = initial !== undefined ? 0 : 1;
+        for (let i = startIdx; i < arr.length; i++) {
+            acc = await fn(acc, arr[i], i);
+        }
+        return acc;
+    };
     builtins.find = async (arr, fn) => {
         if (!Array.isArray(arr))
-            throw new Error('find() requires an array as first argument. Got: ' + (typeof arr));
+            throw new Error('find() requires an array as first argument');
         if (typeof fn !== 'function')
-            throw new Error('find() requires a function as second argument. Got: ' + (typeof fn));
+            throw new Error('find() requires a function as second argument');
         for (let i = 0; i < arr.length; i++) {
-            if (await fn(arr[i], i)) {
+            if (await fn(arr[i], i))
                 return arr[i];
-            }
         }
         return null;
     };
+    builtins.every = async (arr, fn) => {
+        for (const item of arr) {
+            if (!(await fn(item)))
+                return false;
+        }
+        return true;
+    };
+    builtins.some = async (arr, fn) => {
+        for (const item of arr) {
+            if (await fn(item))
+                return true;
+        }
+        return false;
+    };
+    builtins.sort = (arr, fn) => {
+        const copy = [...arr];
+        if (fn) {
+            copy.sort((a, b) => {
+                const result = fn(a, b);
+                return typeof result === 'number' ? result : 0;
+            });
+        }
+        else {
+            copy.sort((a, b) => {
+                if (typeof a === 'number' && typeof b === 'number')
+                    return a - b;
+                return String(a).localeCompare(String(b));
+            });
+        }
+        return copy;
+    };
+    builtins.reverse = (arr) => [...arr].reverse();
+    builtins.slice = (arr, start, end) => arr.slice(start, end);
+    builtins.concat = (...arrays) => arrays.flat();
+    builtins.push = (arr, ...items) => {
+        if (!Array.isArray(arr))
+            throw new Error('push() requires an array as first argument');
+        arr.push(...items);
+        return arr;
+    };
+    builtins.pop = (arr) => {
+        if (!Array.isArray(arr))
+            throw new Error('pop() requires an array as first argument');
+        return arr.pop();
+    };
+    builtins.shift = (arr) => arr.shift();
+    builtins.unshift = (arr, ...items) => { arr.unshift(...items); return arr; };
     builtins.includes = (arr, item) => {
         if (Array.isArray(arr))
             return arr.includes(item);
@@ -185,28 +238,71 @@ export function createBuiltins(config, print) {
             return arr.includes(String(item));
         return false;
     };
+    builtins.indexOf = (arr, item) => arr.indexOf(item);
+    builtins.join = (arr, separator = ',') => {
+        if (!Array.isArray(arr))
+            throw new Error('join() requires an array as first argument');
+        return arr.map(a => stringify(a)).join(separator);
+    };
+    builtins.split = (str, separator) => String(str).split(separator);
+    builtins.keys = (obj) => {
+        if (typeof obj === 'object' && obj !== null)
+            return Object.keys(obj);
+        return [];
+    };
+    builtins.values = (obj) => {
+        if (typeof obj === 'object' && obj !== null)
+            return Object.values(obj);
+        return [];
+    };
+    builtins.entries = (obj) => {
+        if (typeof obj === 'object' && obj !== null)
+            return Object.entries(obj);
+        return [];
+    };
     // ============================================
     // String Functions
     // ============================================
-    builtins.trim = (str) => String(str).trim();
-    builtins.lower = (str) => String(str).toLowerCase();
     builtins.upper = (str) => String(str).toUpperCase();
-    builtins.replace = (str, search, replacement) => {
-        return String(str).replace(String(search), String(replacement));
-    };
-    builtins.replaceAll = (str, search, replacement) => {
-        return String(str).replaceAll(String(search), String(replacement));
+    builtins.lower = (str) => String(str).toLowerCase();
+    builtins.trim = (str) => String(str).trim();
+    builtins.ltrim = (str) => String(str).trimStart();
+    builtins.rtrim = (str) => String(str).trimEnd();
+    builtins.startsWith = (str, prefix) => String(str).startsWith(prefix);
+    builtins.endsWith = (str, suffix) => String(str).endsWith(suffix);
+    builtins.contains = (str, substr) => String(str).includes(substr);
+    builtins.replace = (str, search, replace) => String(str).split(search).join(replace);
+    builtins.replaceAll = (str, search, replace) => String(str).split(search).join(replace);
+    builtins.substr = (str, start, length) => {
+        if (length !== undefined)
+            return String(str).substring(start, start + length);
+        return String(str).substring(start);
+    };
+    builtins.charAt = (str, index) => String(str).charAt(index);
+    builtins.repeat = (str, count) => String(str).repeat(count);
+    builtins.padStart = (str, length, char = ' ') => String(str).padStart(length, char);
+    builtins.padEnd = (str, length, char = ' ') => String(str).padEnd(length, char);
+    builtins.format = (template, ...args) => {
+        let result = template;
+        for (let i = 0; i < args.length; i++) {
+            result = result.replace(`{${i}}`, stringify(args[i]));
+            result = result.replace('{}', stringify(args[i]));
+        }
+        return result;
     };
-    builtins.startsWith = (str, prefix) => String(str).startsWith(String(prefix));
-    builtins.endsWith = (str, suffix) => String(str).endsWith(String(suffix));
-    builtins.contains = (str, search) => String(str).includes(String(search));
     builtins.match = (str, pattern) => {
-        const match = String(str).match(new RegExp(String(pattern)));
-        return match ? Array.from(match) : null;
+        const m = String(str).match(new RegExp(String(pattern)));
+        return m ? Array.from(m) : null;
     };
     // ============================================
     // Math Functions
     // ============================================
+    builtins.abs = Math.abs;
+    builtins.ceil = Math.ceil;
+    builtins.floor = Math.floor;
+    builtins.round = Math.round;
+    builtins.sqrt = Math.sqrt;
+    builtins.pow = Math.pow;
     builtins.min = (...args) => {
         const nums = args.flat().map(Number);
         return Math.min(...nums);
@@ -215,323 +311,363 @@ export function createBuiltins(config, print) {
         const nums = args.flat().map(Number);
         return Math.max(...nums);
     };
-    builtins.abs = (n) => Math.abs(Number(n));
-    builtins.floor = (n) => Math.floor(Number(n));
-    builtins.ceil = (n) => Math.ceil(Number(n));
-    builtins.round = (n) => Math.round(Number(n));
-    builtins.sqrt = (n) => Math.sqrt(Number(n));
-    builtins.pow = (base, exp) => Math.pow(Number(base), Number(exp));
+    builtins.sin = Math.sin;
+    builtins.cos = Math.cos;
+    builtins.tan = Math.tan;
+    builtins.log = Math.log;
+    builtins.log10 = Math.log10;
+    builtins.exp = Math.exp;
     builtins.random = (max) => {
-        if (max !== undefined) {
+        if (max !== undefined)
             return Math.floor(Math.random() * Number(max));
-        }
         return Math.random();
     };
+    builtins.randomInt = (min, max) => {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    };
+    builtins.sum = (arr) => arr.reduce((a, b) => a + b, 0);
+    builtins.avg = (arr) => arr.length > 0 ? arr.reduce((a, b) => a + b, 0) / arr.length : 0;
+    // Constants
+    builtins.PI = Math.PI;
+    builtins.E = Math.E;
     // ============================================
-    // Time Functions
+    // Date/Time Functions
     // ============================================
-    builtins.time = () => Date.now();
-    builtins.now = () => new Date().toISOString();
-    builtins.sleep = async (ms) => {
-        await new Promise(resolve => setTimeout(resolve, Number(ms)));
-        return null;
+    builtins.now = () => Date.now();
+    builtins.date = () => new Date().toISOString().split('T')[0];
+    builtins.time = () => new Date().toISOString().split('T')[1].split('.')[0];
+    builtins.datetime = () => new Date().toISOString();
+    builtins.timestamp = () => Math.floor(Date.now() / 1000);
+    builtins.formatDate = (timestamp, format) => {
+        const d = new Date(timestamp);
+        if (!format)
+            return d.toISOString();
+        return format
+            .replace('YYYY', String(d.getFullYear()))
+            .replace('MM', String(d.getMonth() + 1).padStart(2, '0'))
+            .replace('DD', String(d.getDate()).padStart(2, '0'))
+            .replace('HH', String(d.getHours()).padStart(2, '0'))
+            .replace('mm', String(d.getMinutes()).padStart(2, '0'))
+            .replace('ss', String(d.getSeconds()).padStart(2, '0'));
     };
     // ============================================
-    // File Operations (grok.file namespace)
+    // JSON Functions
     // ============================================
-    const file = {
-        read: (filePath) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
+    builtins.jsonEncode = (value) => JSON.stringify(value, null, 2);
+    builtins.jsonDecode = (str) => JSON.parse(str);
+    const json = {
+        parse: (str) => JSON.parse(String(str)),
+        stringify: (value, indent) => {
+            return JSON.stringify(value, null, indent ? Number(indent) : undefined);
+        },
+    };
+    builtins.json = json;
+    builtins.JSON = json;
+    // ============================================
+    // Console (from Buddy Script)
+    // ============================================
+    builtins.console = {
+        log: builtins.print,
+        info: builtins.print,
+        warn: (...args) => { print('[WARN] ' + args.map(stringify).join(' ')); return null; },
+        error: (...args) => { print('[ERROR] ' + args.map(stringify).join(' ')); return null; },
+    };
+    // ============================================
+    // Math namespace (from Buddy Script)
+    // ============================================
+    builtins.Math = {
+        min: builtins.min,
+        max: builtins.max,
+        abs: builtins.abs,
+        floor: builtins.floor,
+        ceil: builtins.ceil,
+        round: builtins.round,
+        sqrt: builtins.sqrt,
+        pow: builtins.pow,
+        random: () => Math.random(),
+        PI: Math.PI,
+        E: Math.E,
+    };
+    builtins.Date = {
+        now: () => Date.now(),
+        parse: (str) => Date.parse(String(str)),
+    };
+    // ============================================
+    // File Operations (merged FCS flat + BS namespaced)
+    // ============================================
+    if (config.enableFileOps) {
+        // Flat FCS-style file functions
+        builtins.readFile = (filePath) => {
             const fullPath = resolvePath(String(filePath), config.workdir);
+            return fs.readFileSync(fullPath, 'utf-8');
+        };
+        builtins.writeFile = (filePath, content) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.read: ${fullPath}`);
-                return '';
+                print(`[DRY RUN] Would write to: ${filePath}`);
+                return true;
             }
-            return fs.readFileSync(fullPath, 'utf-8');
-        },
-        write: (filePath, content) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
             const fullPath = resolvePath(String(filePath), config.workdir);
+            fs.writeFileSync(fullPath, content);
+            return true;
+        };
+        builtins.appendFile = (filePath, content) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.write: ${fullPath}`);
+                print(`[DRY RUN] Would append to: ${filePath}`);
                 return true;
             }
-            fs.writeFileSync(fullPath, String(content));
-            return true;
-        },
-        append: (filePath, content) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
             const fullPath = resolvePath(String(filePath), config.workdir);
+            fs.appendFileSync(fullPath, content);
+            return true;
+        };
+        builtins.fileExists = (filePath) => fs.existsSync(resolvePath(String(filePath), config.workdir));
+        builtins.isFile = (filePath) => {
+            try {
+                return fs.statSync(resolvePath(String(filePath), config.workdir)).isFile();
+            }
+            catch {
+                return false;
+            }
+        };
+        builtins.isDir = (filePath) => {
+            try {
+                return fs.statSync(resolvePath(String(filePath), config.workdir)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        };
+        builtins.mkdir = (dirPath) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.append: ${fullPath}`);
+                print(`[DRY RUN] Would create directory: ${dirPath}`);
                 return true;
             }
-            fs.appendFileSync(fullPath, String(content));
+            fs.mkdirSync(resolvePath(String(dirPath), config.workdir), { recursive: true });
             return true;
-        },
-        exists: (filePath) => {
-            const fullPath = resolvePath(String(filePath), config.workdir);
-            return fs.existsSync(fullPath);
-        },
-        delete: (filePath) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
-            const fullPath = resolvePath(String(filePath), config.workdir);
+        };
+        builtins.rmdir = (dirPath) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.delete: ${fullPath}`);
+                print(`[DRY RUN] Would remove directory: ${dirPath}`);
                 return true;
             }
-            fs.unlinkSync(fullPath);
+            fs.rmSync(resolvePath(String(dirPath), config.workdir), { recursive: true });
             return true;
-        },
-        copy: (src, dest) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
-            const srcPath = resolvePath(String(src), config.workdir);
-            const destPath = resolvePath(String(dest), config.workdir);
+        };
+        builtins.remove = (filePath) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.copy: ${srcPath} -> ${destPath}`);
+                print(`[DRY RUN] Would remove: ${filePath}`);
                 return true;
             }
-            fs.copyFileSync(srcPath, destPath);
+            fs.unlinkSync(resolvePath(String(filePath), config.workdir));
             return true;
-        },
-        move: (src, dest) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
-            const srcPath = resolvePath(String(src), config.workdir);
-            const destPath = resolvePath(String(dest), config.workdir);
+        };
+        builtins.rename = (oldPath, newPath) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.move: ${srcPath} -> ${destPath}`);
+                print(`[DRY RUN] Would rename: ${oldPath} -> ${newPath}`);
                 return true;
             }
-            fs.renameSync(srcPath, destPath);
+            fs.renameSync(resolvePath(String(oldPath), config.workdir), resolvePath(String(newPath), config.workdir));
             return true;
-        },
-        list: (dirPath) => {
-            const fullPath = resolvePath(String(dirPath), config.workdir);
-            return fs.readdirSync(fullPath);
-        },
-        mkdir: (dirPath) => {
-            if (!config.enableFileOps)
-                throw new Error('File operations are disabled in the current script configuration. Enable them with { enableFileOps: true }.');
-            const fullPath = resolvePath(String(dirPath), config.workdir);
+        };
+        builtins.copy = (src, dest) => {
             if (config.dryRun) {
-                print(`[DRY RUN] file.mkdir: ${fullPath}`);
+                print(`[DRY RUN] Would copy: ${src} -> ${dest}`);
                 return true;
             }
-            fs.mkdirSync(fullPath, { recursive: true });
+            fs.copyFileSync(resolvePath(String(src), config.workdir), resolvePath(String(dest), config.workdir));
             return true;
-        },
-        stat: (filePath) => {
-            const fullPath = resolvePath(String(filePath), config.workdir);
-            const stats = fs.statSync(fullPath);
-            return {
-                size: stats.size,
-                isFile: stats.isFile(),
-                isDirectory: stats.isDirectory(),
-                created: stats.birthtime.toISOString(),
-                modified: stats.mtime.toISOString(),
-            };
-        },
-        glob: (pattern) => {
-            // Simple glob implementation
-            const fullPath = resolvePath(String(pattern), config.workdir);
-            const dir = path.dirname(fullPath);
-            const base = path.basename(fullPath);
-            if (!fs.existsSync(dir))
+        };
+        builtins.listDir = (dirPath) => fs.readdirSync(resolvePath(String(dirPath), config.workdir));
+        builtins.glob = (pattern) => {
+            const dir = path.dirname(pattern);
+            const filePattern = path.basename(pattern);
+            const fullDir = resolvePath(dir, config.workdir);
+            if (!fs.existsSync(fullDir))
                 return [];
-            const files = fs.readdirSync(dir);
-            const regex = new RegExp('^' + base.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
-            return files.filter(f => regex.test(f)).map(f => path.join(dir, f));
-        },
-    };
-    builtins.file = file;
+            const regex = new RegExp('^' + filePattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+            return fs.readdirSync(fullDir).filter(f => regex.test(f)).map(f => path.join(dir, f));
+        };
+        builtins.fileSize = (filePath) => fs.statSync(resolvePath(String(filePath), config.workdir)).size;
+        builtins.fileMtime = (filePath) => fs.statSync(resolvePath(String(filePath), config.workdir)).mtimeMs;
+        // Path utilities
+        builtins.basename = path.basename;
+        builtins.dirname = path.dirname;
+        builtins.extname = path.extname;
+        builtins.joinPath = (...parts) => path.join(...parts);
+        builtins.resolvePath = (...parts) => path.resolve(config.workdir, ...parts);
+        // BS-style namespaced file object
+        builtins.file = {
+            read: (filePath) => builtins.readFile(String(filePath)),
+            write: (filePath, content) => builtins.writeFile(String(filePath), String(content)),
+            append: (filePath, content) => builtins.appendFile(String(filePath), String(content)),
+            exists: (filePath) => builtins.fileExists(String(filePath)),
+            delete: (filePath) => builtins.remove(String(filePath)),
+            copy: (src, dest) => builtins.copy(String(src), String(dest)),
+            move: (src, dest) => builtins.rename(String(src), String(dest)),
+            list: (dirPath) => builtins.listDir(String(dirPath)),
+            mkdir: (dirPath) => builtins.mkdir(String(dirPath)),
+            stat: (filePath) => {
+                const stats = fs.statSync(resolvePath(String(filePath), config.workdir));
+                return { size: stats.size, isFile: stats.isFile(), isDirectory: stats.isDirectory(), created: stats.birthtime.toISOString(), modified: stats.mtime.toISOString() };
+            },
+            glob: (pattern) => builtins.glob(String(pattern)),
+        };
+    }
     // ============================================
-    // Bash/Shell Operations
+    // Shell/Bash Functions (merged FCS flat + BS namespaced)
     // ============================================
-    const bash = {
-        run: (command, options) => {
-            if (!config.enableBash)
-                throw new Error('Bash/shell commands are disabled in the current script configuration. Enable them with { enableBash: true }.');
-            const opts = options || {};
+    if (config.enableBash) {
+        builtins.exec = (command) => {
             if (config.dryRun) {
-                print(`[DRY RUN] bash: ${command}`);
-                return { stdout: '', stderr: '', code: 0 };
+                print(`[DRY RUN] Would execute: ${command}`);
+                return '';
             }
             try {
-                const stdout = execSync(String(command), {
-                    cwd: opts.cwd ? String(opts.cwd) : config.workdir,
-                    encoding: 'utf-8',
-                    timeout: opts.timeout ? Number(opts.timeout) : 30000,
-                    maxBuffer: 10 * 1024 * 1024,
-                });
-                return {
-                    stdout: stdout.trim(),
-                    stderr: '',
-                    code: 0,
-                };
+                return execSync(command, { cwd: config.workdir, encoding: 'utf-8', timeout: config.timeout });
             }
-            catch (error) {
-                const execError = error;
-                return {
-                    stdout: execError.stdout || '',
-                    stderr: execError.stderr || String(error),
-                    code: execError.status || 1,
-                };
+            catch (err) {
+                throw new Error(`Command failed: ${err.message}`);
             }
-        },
-        exec: (command) => {
-            const result = bash.run(command);
-            if (result.code !== 0) {
-                throw new Error(`Command failed with code ${result.code}`);
+        };
+        builtins.shell = async (command) => {
+            if (config.dryRun) {
+                print(`[DRY RUN] Would execute: ${command}`);
+                return { code: 0, stdout: '', stderr: '' };
             }
-            return result.stdout;
-        },
-        spawn: async (command, args) => {
-            if (!config.enableBash)
-                throw new Error('Bash/shell commands are disabled in the current script configuration. Enable them with { enableBash: true }.');
-            const argList = Array.isArray(args) ? args.map(String) : [];
-            return new Promise((resolve, reject) => {
-                const proc = spawn(String(command), argList, {
-                    cwd: config.workdir,
-                    shell: true,
-                });
-                let stdout = '';
-                let stderr = '';
-                proc.stdout?.on('data', (data) => {
-                    stdout += data.toString();
-                    if (config.verbose)
-                        print(data.toString());
-                });
-                proc.stderr?.on('data', (data) => {
-                    stderr += data.toString();
-                });
-                proc.on('close', (code) => {
-                    resolve({ stdout, stderr, code });
-                });
-                proc.on('error', reject);
+            return new Promise((resolve) => {
+                const child = spawn(command, { shell: true, cwd: config.workdir });
+                let stdout = '', stderr = '';
+                child.stdout.on('data', (data) => { stdout += data.toString(); });
+                child.stderr.on('data', (data) => { stderr += data.toString(); });
+                child.on('close', (code) => { resolve({ code: code ?? 0, stdout, stderr }); });
             });
-        },
-    };
-    builtins.bash = bash;
+        };
+        // BS-style namespaced bash object
+        builtins.bash = {
+            run: (command, options) => {
+                if (!config.enableBash)
+                    throw new Error('Bash commands are disabled');
+                const opts = options || {};
+                if (config.dryRun) {
+                    print(`[DRY RUN] bash: ${command}`);
+                    return { stdout: '', stderr: '', code: 0 };
+                }
+                try {
+                    const stdout = execSync(String(command), {
+                        cwd: opts.cwd ? String(opts.cwd) : config.workdir,
+                        encoding: 'utf-8',
+                        timeout: opts.timeout ? Number(opts.timeout) : 30000,
+                        maxBuffer: 10 * 1024 * 1024,
+                    });
+                    return { stdout: stdout.trim(), stderr: '', code: 0 };
+                }
+                catch (error) {
+                    const execError = error;
+                    return { stdout: execError.stdout || '', stderr: execError.stderr || String(error), code: execError.status || 1 };
+                }
+            },
+            exec: (command) => {
+                const result = builtins.bash.run(command);
+                if (result.code !== 0)
+                    throw new Error(`Command failed with code ${result.code}`);
+                return result.stdout;
+            },
+            spawn: async (command, args) => {
+                if (!config.enableBash)
+                    throw new Error('Bash commands are disabled');
+                const argList = Array.isArray(args) ? args.map(String) : [];
+                return new Promise((resolve, reject) => {
+                    const proc = spawn(String(command), argList, { cwd: config.workdir, shell: true });
+                    let stdout = '', stderr = '';
+                    proc.stdout?.on('data', (data) => { stdout += data.toString(); if (config.verbose)
+                        print(data.toString()); });
+                    proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+                    proc.on('close', (code) => { resolve({ stdout, stderr, code }); });
+                    proc.on('error', reject);
+                });
+            },
+        };
+    }
     // ============================================
-    // AI Operations (placeholder - will integrate with CodeBuddyAgent)
+    // AI Operations (from Buddy Script with lazy agent)
     // ============================================
-    const ai = {
-        ask: async (prompt) => {
-            if (!config.enableAI)
-                throw new Error('AI operations are disabled in the current script configuration. Enable them with { enableAI: true }.');
-            if (config.dryRun) {
-                print(`[DRY RUN] ai.ask: ${prompt}`);
-                return '[AI Response Placeholder]';
-            }
-            const agent = await getOrCreateAgent(config);
-            if (!agent) {
-                throw new Error('AI agent not available. Ensure GROK_API_KEY is set.');
-            }
-            const result = await agent.processUserInput(String(prompt));
-            return result.content || '';
-        },
-        chat: async (message) => {
-            if (!config.enableAI)
-                throw new Error('AI operations are disabled in the current script configuration. Enable them with { enableAI: true }.');
-            if (config.dryRun) {
-                print(`[DRY RUN] ai.chat: ${message}`);
-                return '[AI Response Placeholder]';
-            }
-            const agent = await getOrCreateAgent(config);
-            if (!agent) {
-                throw new Error('AI agent not available. Ensure GROK_API_KEY is set.');
-            }
-            const result = await agent.processUserInput(String(message));
-            return result.content || '';
-        },
-        complete: async (prompt, options) => {
-            if (!config.enableAI)
-                throw new Error('AI operations are disabled in the current script configuration. Enable them with { enableAI: true }.');
-            if (config.dryRun) {
-                print(`[DRY RUN] ai.complete: ${prompt}`);
-                return '[AI Response Placeholder]';
-            }
-            const agent = await getOrCreateAgent(config);
-            if (!agent) {
-                throw new Error('AI agent not available. Ensure GROK_API_KEY is set.');
-            }
-            const opts = typeof options === 'object' && options !== null ? options : {};
-            const result = await agent.processUserInput(String(prompt), opts);
-            return result.content || '';
-        },
-    };
-    builtins.ai = ai;
+    if (config.enableAI) {
+        const ai = {
+            ask: async (prompt) => {
+                if (config.dryRun) {
+                    print(`[DRY RUN] ai.ask: ${prompt}`);
+                    return '[AI Response Placeholder]';
+                }
+                const agent = await getOrCreateAgent(config);
+                if (!agent)
+                    throw new Error('AI agent not available. Ensure GROK_API_KEY is set.');
+                const result = await agent.processUserInput(String(prompt));
+                return result.content || '';
+            },
+            chat: async (message) => {
+                if (config.dryRun) {
+                    print(`[DRY RUN] ai.chat: ${message}`);
+                    return '[AI Response Placeholder]';
+                }
+                const agent = await getOrCreateAgent(config);
+                if (!agent)
+                    throw new Error('AI agent not available. Ensure GROK_API_KEY is set.');
+                const result = await agent.processUserInput(String(message));
+                return result.content || '';
+            },
+            complete: async (prompt, options) => {
+                if (config.dryRun) {
+                    print(`[DRY RUN] ai.complete: ${prompt}`);
+                    return '[AI Response Placeholder]';
+                }
+                const agent = await getOrCreateAgent(config);
+                if (!agent)
+                    throw new Error('AI agent not available. Ensure GROK_API_KEY is set.');
+                const opts = typeof options === 'object' && options !== null ? options : {};
+                const result = await agent.processUserInput(String(prompt), opts);
+                return result.content || '';
+            },
+        };
+        builtins.ai = ai;
+        // FCS-style flat ai/grok function
+        builtins.grok = async (prompt) => {
+            return ai.ask(prompt);
+        };
+    }
     // ============================================
     // Environment & Config
     // ============================================
-    const env = {
+    builtins.env = {
         get: (name) => process.env[String(name)] || null,
-        set: (name, value) => {
-            process.env[String(name)] = String(value);
-            return true;
-        },
+        set: (name, value) => { process.env[String(name)] = String(value); return true; },
         all: () => ({ ...process.env }),
     };
-    builtins.env = env;
-    const grok = {
-        workdir: () => config.workdir,
-        verbose: () => config.verbose,
-        dryRun: () => config.dryRun,
-        version: () => '1.0.0',
-    };
-    builtins.grok = grok;
-    // ============================================
-    // JSON
-    // ============================================
-    const json = {
-        parse: (str) => JSON.parse(String(str)),
-        stringify: (value, indent) => {
-            return JSON.stringify(value, null, indent ? Number(indent) : undefined);
-        },
-    };
-    builtins.json = json;
-    builtins.JSON = json;
-    // ============================================
-    // Console (alias for print functions)
-    // ============================================
-    const console = {
-        log: builtins.print,
-        info: builtins.print,
-        warn: (...args) => {
-            print('[WARN] ' + args.map(stringify).join(' '));
-            return null;
-        },
-        error: (...args) => {
-            print('[ERROR] ' + args.map(stringify).join(' '));
-            return null;
-        },
-    };
-    builtins.console = console;
+    builtins.cwd = () => config.workdir;
     // ============================================
-    // Math namespace (for compatibility)
+    // Utility Functions
     // ============================================
-    builtins.Math = {
-        min: builtins.min,
-        max: builtins.max,
-        abs: builtins.abs,
-        floor: builtins.floor,
-        ceil: builtins.ceil,
-        round: builtins.round,
-        sqrt: builtins.sqrt,
-        pow: builtins.pow,
-        random: () => Math.random(),
-        PI: Math.PI,
-        E: Math.E,
+    builtins.typeof = (value) => {
+        if (value === null)
+            return 'null';
+        if (Array.isArray(value))
+            return 'array';
+        return typeof value;
     };
-    builtins.Date = {
-        now: () => Date.now(),
-        parse: (str) => Date.parse(String(str)),
+    builtins.isNull = (value) => value === null;
+    builtins.isNumber = (value) => typeof value === 'number';
+    builtins.isString = (value) => typeof value === 'string';
+    builtins.isBool = (value) => typeof value === 'boolean';
+    builtins.isArray = (value) => Array.isArray(value);
+    builtins.isDict = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+    builtins.isFunction = (value) => typeof value === 'function';
+    builtins.sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    builtins.exit = (code = 0) => process.exit(code);
+    builtins.assert = (condition, message) => {
+        if (!condition)
+            throw new Error(message || 'Assertion failed');
+    };
+    builtins.expect = (actual, expected, message) => {
+        if (actual !== expected)
+            throw new Error(message || `Expected ${stringify(expected)}, got ${stringify(actual)}`);
     };
     return builtins;
 }
@@ -543,8 +679,21 @@ function stringify(value) {
         return 'null';
     if (value === undefined)
         return 'undefined';
-    if (typeof value === 'object')
-        return JSON.stringify(value);
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'function')
+        return '[Function]';
+    if (Array.isArray(value)) {
+        return '[' + value.map(v => stringify(v)).join(', ') + ']';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return '[Object]';
+        }
+    }
     return String(value);
 }
 function resolvePath(filePath, workdir) {
@@ -552,4 +701,6 @@ function resolvePath(filePath, workdir) {
         return filePath;
     return path.resolve(workdir, filePath);
 }
+/** @deprecated Use createBuiltins instead */
+export const createFCSBuiltins = createBuiltins;
 //# sourceMappingURL=builtins.js.map