feat: Add String.prototype.phantom for direct method access

- Added .phantom property to String prototype
- Enables direct method access: message.phantom.strings.toUpperCase().trim()
- All chainable methods available via message.phantom.strings.*
- Direct operation access via message.phantom.strings.operation.*
- Added 8 test cases for String.prototype.phantom
- All 316 tests passing

Author: david-labs-ca

phantom.js

@@ -2541,6 +2541,84 @@
       }
     };
 
+    /* --------------------------------------------------
+     * STRING PROTOTYPE EXTENSION
+     * Add .phantom property to strings for direct method access
+     * Usage: message.phantom.strings.toUpperCase().trim().split()...
+     * -------------------------------------------------- */
+    
+    // Add phantom property to String prototype
+    if (typeof String !== "undefined" && String.prototype) {
+      Object.defineProperty(String.prototype, 'phantom', {
+        get: function() {
+          var self = this;
+          return {
+            strings: {
+              // Direct access to chain API
+              chain: function() {
+                return phantom.strings.chain(self);
+              },
+              // Direct access to operations (returns chainable)
+              toUpperCase: function() {
+                return phantom.strings.chain(self).toUpperCase();
+              },
+              toLowerCase: function() {
+                return phantom.strings.chain(self).toLowerCase();
+              },
+              trim: function() {
+                return phantom.strings.chain(self).trim();
+              },
+              leftTrim: function() {
+                return phantom.strings.chain(self).leftTrim();
+              },
+              rightTrim: function() {
+                return phantom.strings.chain(self).rightTrim();
+              },
+              capitalize: function() {
+                return phantom.strings.chain(self).capitalize();
+              },
+              reverse: function() {
+                return phantom.strings.chain(self).reverse();
+              },
+              reverseWords: function() {
+                return phantom.strings.chain(self).reverseWords();
+              },
+              replace: function(search, replace) {
+                return phantom.strings.chain(self).replace(search, replace);
+              },
+              replaceAll: function(search, replace) {
+                return phantom.strings.chain(self).replaceAll(search, replace);
+              },
+              remove: function(str) {
+                return phantom.strings.chain(self).remove(str);
+              },
+              leftPad: function(padChar, count) {
+                return phantom.strings.chain(self).leftPad(padChar, count);
+              },
+              rightPad: function(padChar, count) {
+                return phantom.strings.chain(self).rightPad(padChar, count);
+              },
+              substring: function(start, end) {
+                return phantom.strings.chain(self).substring(start, end);
+              },
+              wordwrap: function(size, cut, everything) {
+                return phantom.strings.chain(self).wordwrap(size, cut, everything);
+              },
+              // Direct operation access (non-chainable, returns value)
+              operation: phantom.strings.operation
+            },
+            numbers: {
+              chain: function() {
+                return phantom.numbers.chain(self);
+              }
+            }
+          };
+        },
+        enumerable: false,
+        configurable: true
+      });
+    }
+    
     // default init
     phantom.init({ silent: true });
 

phantom.test.js

@@ -870,6 +870,76 @@ describe('phantom.strings', () => {
       expect(chain.value()).toBe("test");
     });
   });
+
+  describe('String.prototype.phantom - Direct method access', () => {
+    test('should access phantom methods directly on string', () => {
+      const message = "  HELLO WORLD  ";
+      const result = message.phantom.strings.toUpperCase().trim().value();
+      expect(result).toBe("HELLO WORLD");
+    });
+
+    test('should chain multiple operations directly on string', () => {
+      const message = "  hello world  ";
+      const result = message.phantom.strings
+        .trim()
+        .toUpperCase()
+        .replace("WORLD", "UNIVERSE")
+        .value();
+      expect(result).toBe("HELLO UNIVERSE");
+    });
+
+    test('should work with toLowerCase and capitalize', () => {
+      const message = "  HELLO WORLD  ";
+      const result = message.phantom.strings
+        .trim()
+        .toLowerCase()
+        .capitalize()
+        .value();
+      expect(result).toBe("Hello world");
+    });
+
+    test('should work with substring operation', () => {
+      const message = "hello world";
+      const result = message.phantom.strings
+        .substring(0, 5)
+        .toUpperCase()
+        .value();
+      expect(result).toBe("HELLO");
+    });
+
+    test('should access operation methods directly', () => {
+      const message = "hello";
+      const upper = message.phantom.strings.operation.toUpperCase(message);
+      expect(upper).toBe("HELLO");
+    });
+
+    test('should convert to number chain from string', () => {
+      const message = "123.45";
+      const result = message.phantom.strings
+        .trim()
+        .toNumberChain()
+        .round(1)
+        .value();
+      expect(result).toBe(123.5);
+    });
+
+    test('should work with replace operations', () => {
+      const message = "hello hello hello";
+      const result = message.phantom.strings
+        .replaceAll("hello", "hi")
+        .toUpperCase()
+        .value();
+      expect(result).toBe("HI HI HI");
+    });
+
+    test('should work with padding operations', () => {
+      const message = "5";
+      const result = message.phantom.strings
+        .leftPad("0", 3)
+        .value();
+      expect(result).toBe("0005");
+    });
+  });
 });
 
 describe('phantom.numbers', () => {