@mcpher/gas-fakes 2.5.2 → 2.5.4

package/src/services/xmlservice/fakeformat.js

@@ -5,49 +5,94 @@ import { XMLBuilder } from 'fast-xml-parser';
  */
 export class FakeFormat {
   constructor(options = {}) {
-    this._options = options;
+    this._encoding = 'UTF-8';
+    this._indent = options.pretty ? '  ' : null;
+    this._lineSeparator = '\r\n';
+    this._omitDeclaration = false;
+    this._omitEncoding = false;
+  }
+
+  setEncoding(encoding) {
+    this._encoding = encoding || 'UTF-8';
+    return this;
+  }
+
+  setIndent(indent) {
+    this._indent = indent;
+    return this;
+  }
+
+  setLineSeparator(separator) {
+    this._lineSeparator = separator || '\r\n';
+    return this;
+  }
+
+  setOmitDeclaration(omit) {
+    this._omitDeclaration = !!omit;
+    return this;
+  }
+
+  setOmitEncoding(omit) {
+    this._omitEncoding = !!omit;
+    return this;
   }
 
   /**
-   * Formats the given document as an XML string.
-   * @param {FakeDocument} document The document to format.
+   * Formats the given document or element as an XML string.
+   * @param {FakeDocument|FakeElement} documentOrElement
    * @return {string} The formatted XML string.
    */
-  format(document) {
-    if (!document || typeof document.getRootElement !== 'function') {
-      throw new Error("XmlService: Invalid document provided to format().");
+  format(documentOrElement) {
+    if (!documentOrElement) {
+      throw new Error("XmlService: Invalid argument provided to format().");
     }
 
-    const root = document.getRootElement();
+    let root;
+    if (typeof documentOrElement.getRootElement === 'function') {
+      root = documentOrElement.getRootElement();
+    } else if (typeof documentOrElement.getQualifiedName === 'function') {
+      root = documentOrElement;
+    } else {
+      throw new Error("XmlService: Invalid document/element provided to format().");
+    }
+
+    if (!root) return '';
+
+    const isPretty = this._indent !== null && this._indent !== '';
+    const indentBy = isPretty ? this._indent : '';
+
     const builderOptions = {
       ignoreAttributes: false,
       attributeNamePrefix: "@_",
       textNodeName: "#text",
-      format: this._options.pretty || false,
-      indentBy: this._options.pretty ? "  " : "",
-      suppressEmptyNode: false // GAS usually outputs <tag></tag> or <tag/>? Actually GAS uses <tag/> for empty elements usually.
+      format: isPretty,
+      indentBy: indentBy,
+      suppressEmptyNode: false
     };
 
     const builder = new XMLBuilder(builderOptions);
-
-    // Construct the object for building
-    // We access the internal _data property of FakeElement
     const data = {
       [root.getQualifiedName()]: root._data
     };
 
     let xml = builder.build(data);
 
-    // GAS adds XML declaration followed by a line separator (\r\n)
-    const declaration = '<?xml version="1.0" encoding="UTF-8"?>\r\n';
+    if (isPretty) {
+      // XMLBuilder uses \n, replace with line separator if different
+      if (this._lineSeparator !== '\n') {
+        xml = xml.replace(/\n/g, this._lineSeparator);
+      }
+    }
 
-    if (this._options.pretty) {
-      // GAS pretty format uses \r\n and has a newline after declaration
-      // XMLBuilder uses \n, so we replace it.
-      return declaration + xml.replace(/\n/g, '\r\n') + '\r\n';
-    } else {
-      // Raw format - declaration, compact XML, and trailing newline
-      return declaration + xml + '\r\n';
+    let declaration = '';
+    if (!this._omitDeclaration) {
+      if (this._omitEncoding) {
+        declaration = '<?xml version="1.0"?>' + this._lineSeparator;
+      } else {
+        declaration = `<?xml version="1.0" encoding="${this._encoding}"?>` + this._lineSeparator;
+      }
     }
+
+    return declaration + xml + this._lineSeparator;
   }
 }

package/src/services/xmlservice/fakeprocessinginstruction.js

@@ -0,0 +1,44 @@
+import { FakeContent } from './fakecontent.js';
+import * as Enums from '../enums/xmlenums.js';
+
+export class FakeProcessingInstruction extends FakeContent {
+  constructor(target, data = '') {
+    super(Enums.ContentTypes.PROCESSINGINSTRUCTION);
+    this._target = target;
+    this._data = data;
+  }
+
+  getTarget() {
+    return this._target;
+  }
+
+  setTarget(target) {
+    this._target = target;
+    return this;
+  }
+
+  getData() {
+    return this._data;
+  }
+
+  setData(data) {
+    this._data = data;
+    return this;
+  }
+
+  getValue() {
+    return '';
+  }
+
+  detach() {
+    return super.detach();
+  }
+
+  getParentElement() {
+    return super.getParentElement();
+  }
+
+  toString() {
+    return `[ProcessingInstruction: <?${this._target} ${this._data}?>]`;
+  }
+}

package/src/services/xmlservice/faketext.js

@@ -0,0 +1,39 @@
+import { FakeContent } from './fakecontent.js';
+import * as Enums from '../enums/xmlenums.js';
+
+export class FakeText extends FakeContent {
+  constructor(text = '') {
+    super(Enums.ContentTypes.TEXT);
+    this._text = text;
+  }
+
+  getText() {
+    return this._text;
+  }
+
+  setText(text) {
+    this._text = text || '';
+    return this;
+  }
+
+  getValue() {
+    return this._text;
+  }
+
+  append(text) {
+    this._text += text || '';
+    return this;
+  }
+
+  detach() {
+    return super.detach();
+  }
+
+  getParentElement() {
+    return super.getParentElement();
+  }
+
+  toString() {
+    return `[Text: ${this._text}]`;
+  }
+}

package/src/services/xmlservice/fakexmlservice.js

@@ -0,0 +1,118 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeDocument } from './fakedocument.js';
+import { FakeElement } from './fakeelement.js';
+import { FakeNamespace } from './fakenamespace.js';
+import { FakeFormat } from './fakeformat.js';
+import { FakeAttribute } from './fakeattribute.js';
+import { FakeCdata } from './fakecdata.js';
+import { FakeDocType } from './fakedoctype.js';
+import { FakeComment } from './fakecomment.js';
+import { FakeText } from './faketext.js';
+import { FakeEntityRef } from './fakeentityref.js';
+import { FakeProcessingInstruction } from './fakeprocessinginstruction.js';
+import { XMLParser } from 'fast-xml-parser';
+import * as Enums from '../enums/xmlenums.js';
+
+class FakeXmlService {
+  constructor(contentType = Enums.ContentTypes) {
+    this.ContentTypes = contentType;
+  }
+
+  parse(xml) {
+    const options = {
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      textNodeName: "#text",
+      alwaysCreateTextNode: true,
+      removeNSPrefix: false
+    };
+    const parser = new XMLParser(options);
+    const jsonObj = parser.parse(xml);
+
+    const rootName = Object.keys(jsonObj).find(key => !key.startsWith('?'));
+    if (!rootName) {
+      throw new Error("XmlService: No root element found in XML.");
+    }
+
+    const rootData = jsonObj[rootName];
+    const rootElement = new FakeElement(rootName, rootData);
+    return new FakeDocument(rootElement);
+  }
+
+  getNamespace(prefix, uri) {
+    return new FakeNamespace(prefix, uri);
+  }
+
+  getPrettyFormat() {
+    return new FakeFormat({ pretty: true });
+  }
+
+  getRawFormat() {
+    return new FakeFormat({ pretty: false });
+  }
+
+  getCompactFormat() {
+    // defaults to UTF-8 encoding, no indentation, and no additional line breaks, but includes the XML declaration and its encoding
+    const fmt = new FakeFormat({ pretty: false });
+    fmt.setIndent(null);
+    fmt.setLineSeparator('');
+    return fmt;
+  }
+
+  getNoNamespace() {
+    return new FakeNamespace('', '');
+  }
+
+  getXmlNamespace() {
+    return new FakeNamespace('xml', 'http://www.w3.org/XML/1998/namespace');
+  }
+
+  // Factory methods implemented as instance methods
+  createDocument(rootElement) {
+    if (arguments.length > 0 && (rootElement === null || rootElement === undefined)) {
+      throw new Error("Argument cannot be null: rootElement");
+    }
+    return new FakeDocument(rootElement || null);
+  }
+
+  createElement(name, namespace = null) {
+    const qname = namespace && namespace.getPrefix() ? `${namespace.getPrefix()}:${name}` : name;
+    const el = new FakeElement(qname, {}, null);
+    if (namespace) {
+      el.setNamespace(namespace);
+    }
+    return el;
+  }
+
+  createCdata(text) {
+    return new FakeCdata(text);
+  }
+
+  createComment(text) {
+    return new FakeComment(text);
+  }
+
+  createDocType(name, publicId = null, systemId = null) {
+    return new FakeDocType(name, publicId, systemId);
+  }
+
+  createText(text) {
+    return new FakeText(text);
+  }
+
+  createEntityRef(name, publicId = null, systemId = null) {
+    return new FakeEntityRef(name, publicId, systemId);
+  }
+
+  createProcessingInstruction(target, data = '') {
+    return new FakeProcessingInstruction(target, data);
+  }
+
+  toString() {
+    return "XmlService";
+  }
+}
+
+export const newFakeXmlService = (...args) => {
+  return Proxies.guard(new FakeXmlService(...args));
+};

package/src/support/sxfetch.js

@@ -11,16 +11,76 @@ const fixOptions = (options) => {
   let fixedOptions = {}
   if (options) {
     fixedOptions = { ...options }
+
+    // --- 1. Handle specific advanced parameters ---
+
+    // 1.1. Timeout
+    if (typeof fixedOptions.timeoutSeconds === 'number') {
+      fixedOptions.timeout = { request: fixedOptions.timeoutSeconds * 1000 };
+      delete fixedOptions.timeoutSeconds;
+    }
+
+    // 1.2. Redirects
+    if (typeof fixedOptions.followRedirects === 'boolean') {
+      fixedOptions.followRedirect = fixedOptions.followRedirects;
+      delete fixedOptions.followRedirects;
+    }
+
+    // 1.3. HTTPS Certificate Validation
+    if (typeof fixedOptions.validateHttpsCertificates === 'boolean') {
+      fixedOptions.https = fixedOptions.https || {};
+      fixedOptions.https.rejectUnauthorized = fixedOptions.validateHttpsCertificates;
+      delete fixedOptions.validateHttpsCertificates;
+    }
+
+    // 1.4. Escaping (Note: got handles escaping natively, this is primarily for documentation/acceptance)
+    if (typeof fixedOptions.escaping === 'boolean') {
+      // If escaping is false, we assume the URL provided is already fully escaped/raw.
+      // We accept the parameter but rely on got's default behavior unless we manually modify the URL, 
+      // which is complex and usually unnecessary for standard fetch implementations.
+      delete fixedOptions.escaping; 
+    }
+
+    // 1.5. Payload Handling (Blob or Byte Array)
+    if (fixedOptions.payload) {
+      const payload = fixedOptions.payload;
+      
+      // Check for Blob-like object (has getBytes and getContentType)
+      if (typeof payload === 'object' && payload !== null && typeof payload.getBytes === 'function' && typeof payload.getContentType === 'function') {
+        const bytes = payload.getBytes();
+        fixedOptions.body = Buffer.from(bytes);
+        
+        // Set Content-Type if not already specified
+        const contentType = payload.getContentType();
+        if (!fixedOptions.headers || !fixedOptions.headers['Content-Type'] || fixedOptions.headers['Content-Type'] !== contentType) {
+          fixedOptions.headers = fixedOptions.headers || {};
+          fixedOptions.headers['Content-Type'] = contentType;
+        }
+        delete fixedOptions.payload;
+        
+      // Check for Byte Array (Array of numbers)
+      } else if (Array.isArray(payload) && payload.every(item => typeof item === 'number')) {
+        fixedOptions.body = Buffer.from(payload);
+        delete fixedOptions.payload;
+      }
+    }
+
+
+    // --- 2. Handle existing options (Content-Type, payload object, muteHttpExceptions) ---
+
     Object.keys(fixedOptions).forEach(k => {
+      // Content-Type handling
       if (k.match(/Content-Type|contentType/i)) {
         fixedOptions.headers = fixedOptions.headers || {}
         fixedOptions.headers['Content-Type'] = fixedOptions[k]
         delete fixedOptions[k]
       }
+      // Payload object handling (for application/x-www-form-urlencoded)
       if (k.match(/payload/i)) {
         fixedOptions.body = fixedOptions[k]
         delete fixedOptions[k]
       }
+      // Mute HTTP Exceptions
       if (k.match(/muteHttpExceptions/i)) {
         fixedOptions.throwHttpErrors = !fixedOptions[k]
         delete fixedOptions[k]

package/tools/omlx.env.example

@@ -0,0 +1,6 @@
+# Optional overrides for tools/omlx_mcp_server.cjs
+# Export in your shell or set in ~/.cursor/mcp.json env block.
+
+AGY_CUSTOM_BASE_URL=http://localhost:8000/v1
+AGY_DEFAULT_MODEL=gemma-4-e4b-it-OptiQ-4bit
+AGY_CUSTOM_API_KEY=your-api-key-here

package/tools/omlx_mcp_server.cjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const logFile = process.env.OMLX_MCP_LOG
+  || path.join(process.cwd(), 'gasmess', 'omlx_mcp.log');
+
+function log(msg) {
+  try {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    fs.appendFileSync(logFile, `[${new Date().toISOString()}] ${msg}\n`);
+  } catch {
+    // Logging must not break the MCP server.
+  }
+}
+
+log('Starting oMLX MCP Server...');
+
+function envOr(key, fallback) {
+  const value = process.env[key];
+  return value && value.trim() ? value : fallback;
+}
+
+const BASE_URL = envOr('AGY_CUSTOM_BASE_URL', 'http://localhost:8000/v1');
+const MODEL = envOr('AGY_DEFAULT_MODEL', 'gemma-4-e4b-it-OptiQ-4bit');
+const API_KEY = envOr('AGY_CUSTOM_API_KEY', 'trumpity');
+
+log(`Configuration: URL=${BASE_URL}, MODEL=${MODEL}, LOG=${logFile}`);
+
+let buffer = '';
+
+process.stdin.on('data', (chunk) => {
+  buffer += chunk.toString();
+  let lineEndIndex;
+  while ((lineEndIndex = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, lineEndIndex).trim();
+    buffer = buffer.slice(lineEndIndex + 1);
+    if (line) {
+      handleMessage(line);
+    }
+  }
+});
+
+async function handleMessage(line) {
+  try {
+    log(`Received: ${line}`);
+    const request = JSON.parse(line);
+
+    if (request.method === 'initialize') {
+      sendResponse({
+        jsonrpc: '2.0',
+        id: request.id,
+        result: {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'omlx-mcp', version: '1.0.0' }
+        }
+      });
+    } else if (request.method === 'notifications/initialized') {
+      log('Initialized notification received');
+    } else if (request.method === 'tools/list') {
+      sendResponse({
+        jsonrpc: '2.0',
+        id: request.id,
+        result: {
+          tools: [
+            {
+              name: 'query_local_model',
+              description: 'Send a prompt or coding instruction to the locally running oMLX model and get its response.',
+              inputSchema: {
+                type: 'object',
+                properties: {
+                  prompt: {
+                    type: 'string',
+                    description: 'The prompt or instruction to send to the local model.'
+                  }
+                },
+                required: ['prompt']
+              }
+            }
+          ]
+        }
+      });
+    } else if (request.method === 'tools/call') {
+      const toolName = request.params.name;
+      const toolArgs = request.params.arguments || {};
+
+      if (toolName === 'query_local_model') {
+        const prompt = toolArgs.prompt;
+        log(`Calling query_local_model with prompt length: ${prompt?.length ?? 0}`);
+
+        try {
+          const resultText = await queryOmlx(prompt);
+          sendResponse({
+            jsonrpc: '2.0',
+            id: request.id,
+            result: {
+              content: [{ type: 'text', text: resultText }]
+            }
+          });
+        } catch (err) {
+          log(`Error querying oMLX: ${err.message}`);
+          sendError(request.id, -32603, `Failed to query oMLX model: ${err.message}`);
+        }
+      } else {
+        sendError(request.id, -32601, `Tool not found: ${toolName}`);
+      }
+    } else if (request.id !== undefined) {
+      sendError(request.id, -32601, `Method not found: ${request.method}`);
+    }
+  } catch (err) {
+    log(`Error handling message: ${err.message}`);
+  }
+}
+
+function sendResponse(response) {
+  const line = JSON.stringify(response) + '\n';
+  log(`Sending: ${line.trim()}`);
+  process.stdout.write(line);
+}
+
+function sendError(id, code, message) {
+  sendResponse({
+    jsonrpc: '2.0',
+    id,
+    error: { code, message }
+  });
+}
+
+async function queryOmlx(prompt) {
+  const url = `${BASE_URL.replace(/\/$/, '')}/chat/completions`;
+  log(`Fetching oMLX at ${url}`);
+
+  const headers = { 'Content-Type': 'application/json' };
+  if (API_KEY) {
+    headers.Authorization = `Bearer ${API_KEY}`;
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      model: MODEL,
+      messages: [{ role: 'user', content: prompt }],
+      temperature: 0.1
+    })
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+
+  const data = await response.json();
+  return data.choices[0].message.content;
+}