@probelabs/probe 0.6.0-rc231 → 0.6.0-rc233

package/build/agent/dsl/analyze-test.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+/**
+ * Real-world test of the analyze_all replacement pattern.
+ *
+ * Tests against the TykTechnologies/customer-insights repo (582 markdown files, 16MB)
+ * to verify the search → chunk → map(LLM) → synthesize pipeline works at scale.
+ *
+ * Usage:
+ *   node npm/src/agent/dsl/analyze-test.mjs
+ */
+
+import { createDSLRuntime } from './runtime.js';
+import { search } from '../../search.js';
+import { extract } from '../../extract.js';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { generateText } from 'ai';
+import { config } from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '../../../..');
+
+config({ path: resolve(projectRoot, '.env') });
+
+const apiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
+if (!apiKey) {
+  console.error('ERROR: No Google API key found.');
+  process.exit(1);
+}
+
+const google = createGoogleGenerativeAI({ apiKey });
+
+async function llmCall(instruction, data, options = {}) {
+  const dataStr = data == null ? '' : (typeof data === 'string' ? data : JSON.stringify(data, null, 2));
+  const prompt = (dataStr || '(empty)').substring(0, 100000);
+  const result = await generateText({
+    model: google('gemini-2.5-flash'),
+    system: instruction,
+    prompt,
+    temperature: options.temperature || 0.3,
+    maxTokens: options.maxTokens || 4000,
+  });
+  return result.text;
+}
+
+const TARGET_REPO = '/tmp/customer-insights';
+
+const toolImplementations = {
+  search: {
+    execute: async (params) => {
+      try {
+        return await search({
+          query: params.query,
+          path: params.path || TARGET_REPO,
+          cwd: TARGET_REPO,
+          maxTokens: 20000,
+          timeout: 30,
+          exact: params.exact || false,
+        });
+      } catch (e) {
+        return "Search error: " + e.message;
+      }
+    },
+  },
+  extract: {
+    execute: async (params) => {
+      try {
+        return await extract({
+          targets: params.targets,
+          input_content: params.input_content,
+          cwd: TARGET_REPO,
+        });
+      } catch (e) {
+        return "Extract error: " + e.message;
+      }
+    },
+  },
+};
+
+const runtime = createDSLRuntime({
+  toolImplementations,
+  llmCall,
+  mapConcurrency: 3,
+  timeoutMs: 120000,
+  maxLoopIterations: 5000,
+});
+
+// ── Tests ──
+let testNum = 0;
+let passed = 0;
+let failed = 0;
+
+async function runTest(name, code, check) {
+  testNum++;
+  console.log(`\n${'─'.repeat(70)}`);
+  console.log(`▶ Test ${testNum}: ${name}`);
+  console.log(`  Code (${code.trim().split('\n').length} lines):`);
+  const preview = code.trim().split('\n').slice(0, 8).map(l => '    ' + l.trim()).join('\n');
+  console.log(preview);
+  if (code.trim().split('\n').length > 8) console.log('    ...');
+
+  const start = Date.now();
+  try {
+    const result = await runtime.execute(code, name);
+    const elapsed = Date.now() - start;
+
+    if (result.status === 'error') {
+      console.log(`  ✗ EXECUTION ERROR (${elapsed}ms)`);
+      console.log(`  Error: ${result.error.substring(0, 300)}`);
+      if (result.logs.length) console.log(`  Logs: ${result.logs.join(' | ')}`);
+      failed++;
+      return;
+    }
+
+    const userLogs = result.logs.filter(l => !l.startsWith('[runtime]'));
+    if (userLogs.length) {
+      console.log(`  Logs: ${userLogs.join(' | ')}`);
+    }
+
+    const checkResult = check(result);
+    if (checkResult === true) {
+      console.log(`  ✓ PASSED (${elapsed}ms)`);
+      const resultStr = typeof result.result === 'string'
+        ? result.result.substring(0, 500)
+        : JSON.stringify(result.result, null, 2).substring(0, 500);
+      console.log(`  Result: ${resultStr}${resultStr.length >= 500 ? '...' : ''}`);
+      passed++;
+    } else {
+      console.log(`  ✗ CHECK FAILED (${elapsed}ms) — ${checkResult}`);
+      failed++;
+    }
+  } catch (e) {
+    const elapsed = Date.now() - start;
+    console.log(`  ✗ CRASHED (${elapsed}ms) — ${e.message}`);
+    failed++;
+  }
+}
+
+async function main() {
+  console.log('═'.repeat(70));
+  console.log('  analyze_all Replacement — Real-World Tests');
+  console.log('  Target: TykTechnologies/customer-insights (582 .md files, 16MB)');
+  console.log('═'.repeat(70));
+
+  // Test 1: Core analyze_all pattern — search → chunk → map(LLM) → synthesize
+  await runTest(
+    'analyze_all pattern: "api governance"',
+    `
+      const results = search("api governance");
+      log("Search returned " + String(results).length + " chars");
+      const chunks = chunk(results);
+      log("Split into " + chunks.length + " chunks");
+      const extracted = map(chunks, (c) => LLM("List every mention of API governance — who uses it, what for, any specific policies or tools mentioned. Be brief and factual.", c));
+      var combined = "";
+      for (const e of extracted) { combined = combined + String(e) + "\\n---\\n"; }
+      return LLM("Synthesize into a comprehensive report about API governance across all customers. Group by: 1) Customers using API governance, 2) Governance tools/approaches, 3) Common patterns. Be thorough.", combined);
+    `,
+    (r) => {
+      if (typeof r.result !== 'string') return 'Expected string result';
+      if (r.result.length < 100) return 'Result too short: ' + r.result.length;
+      return true;
+    }
+  );
+
+  // Test 2: Multi-topic search — governance + rate limiting + security
+  await runTest(
+    'Multi-topic: governance, rate limiting, security policies',
+    `
+      const topics = ["api governance", "rate limiting", "security policy"];
+      const allFindings = [];
+      for (const topic of topics) {
+        const results = search(topic);
+        log(topic + ": " + String(results).length + " chars");
+        const chunks = chunk(results);
+        const findings = map(chunks, (c) => LLM("Extract key findings about " + topic + ". Include customer names and specifics. Be brief.", c));
+        for (const f of findings) { allFindings.push(topic + ": " + String(f)); }
+      }
+      var combined = "";
+      for (const f of allFindings) { combined = combined + f + "\\n---\\n"; }
+      return LLM("Create a cross-topic analysis: How do customers approach API governance, rate limiting, and security together? What patterns emerge?", combined);
+    `,
+    (r) => {
+      if (typeof r.result !== 'string') return 'Expected string result';
+      if (r.result.length < 100) return 'Result too short';
+      return true;
+    }
+  );
+
+  // Test 3: Extract specific data points
+  await runTest(
+    'Extract customer use cases for API management',
+    `
+      const results = search("use case API management");
+      log("Search: " + String(results).length + " chars");
+      const chunks = chunk(results);
+      log("Chunks: " + chunks.length);
+      const extracted = map(chunks, (c) => LLM("Extract a JSON array of objects with fields: customer (string), use_case (string), outcome (string or null). Only include clearly stated use cases. Return valid JSON array only.", c));
+      var allUseCases = [];
+      for (const e of extracted) {
+        try {
+          var text = String(e).trim();
+          var jsonStart = text.indexOf("[");
+          var jsonEnd = text.lastIndexOf("]");
+          if (jsonStart >= 0 && jsonEnd > jsonStart) {
+            text = text.substring(jsonStart, jsonEnd + 1);
+          }
+          var parsed = JSON.parse(text);
+          if (Array.isArray(parsed)) {
+            for (const item of parsed) { allUseCases.push(item); }
+          }
+        } catch (err) {
+          log("Parse failed for chunk, skipping");
+        }
+      }
+      log("Total use cases found: " + allUseCases.length);
+      return allUseCases;
+    `,
+    (r) => {
+      if (!Array.isArray(r.result)) return 'Expected array result';
+      if (r.result.length === 0) return 'No use cases extracted';
+      return true;
+    }
+  );
+
+  // ── Summary ──
+  console.log(`\n${'═'.repeat(70)}`);
+  console.log(`  Results: ${passed} passed, ${failed} failed, ${testNum} total`);
+  console.log('═'.repeat(70));
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch(e => {
+  console.error('Fatal error:', e);
+  process.exit(1);
+});

package/build/agent/dsl/diag-test.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Diagnostic test — traces exactly what execute_plan returns through ProbeAgent.
+ */
+
+import { ProbeAgent } from '../ProbeAgent.js';
+import { config } from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '../../../..');
+
+config({ path: resolve(projectRoot, '.env') });
+
+const apiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
+if (!apiKey) {
+  console.error('ERROR: No Google API key found');
+  process.exit(1);
+}
+
+const agent = new ProbeAgent({
+  path: '/tmp/customer-insights',
+  provider: 'google',
+  model: 'gemini-2.5-flash',
+  enableExecutePlan: true,
+  maxIterations: 15,
+});
+
+let callNum = 0;
+
+agent.events.on('toolCall', (event) => {
+  if (event.status === 'started') {
+    if (event.name === 'execute_plan') {
+      callNum++;
+      console.log(`\n>>> EXECUTE_PLAN #${callNum} START`);
+      console.log(`>>> CODE:\n${String(event.args?.code || '').substring(0, 1200)}`);
+      if (String(event.args?.code || '').length > 1200) console.log('>>> ... (truncated)');
+    }
+  }
+  if (event.status === 'error') {
+    console.log(`>>> TOOL ERROR: ${event.name}: ${event.error}`);
+  }
+});
+
+await agent.initialize();
+
+// Monkey-patch to see full results
+const origExecute = agent.toolImplementations.execute_plan.execute;
+agent.toolImplementations.execute_plan.execute = async (params) => {
+  const result = await origExecute(params);
+  const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+  console.log(`\n>>> EXECUTE_PLAN #${callNum} RETURNED (${resultStr.length} chars):`);
+  console.log(`>>> ${resultStr.substring(0, 500)}`);
+  if (resultStr.length > 500) console.log(`>>> ... (${resultStr.length - 500} more chars)`);
+  return result;
+};
+
+const query = 'Analyze ALL customer files in this repository. For every customer, classify them by industry. Produce a markdown table with columns: Customer, Industry, Use Case.';
+
+console.log(`\nQUERY: ${query}\n`);
+
+try {
+  const result = await Promise.race([
+    agent.answer(query),
+    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout 600s')), 600000)),
+  ]);
+
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`FINAL RESULT (${String(result).length} chars):`);
+  console.log(String(result).substring(0, 2000));
+  console.log(`${'='.repeat(60)}`);
+} catch (e) {
+  console.log(`\nFAILED: ${e.message}`);
+}
+
+try { await agent.close(); } catch (e) {}
+process.exit(0);

package/build/agent/dsl/environment.js

@@ -0,0 +1,387 @@
+/**
+ * Tool Environment Generator
+ *
+ * Reads Zod schemas (native tools) and MCP tool schemas to generate:
+ * 1. Sandbox globals object (function bindings that bridge to real tools)
+ * 2. Set of async function names (for the AST transformer)
+ */
+
+import {
+  searchSchema,
+  querySchema,
+  extractSchema,
+  bashSchema,
+} from '../../tools/common.js';
+
+// Map of native tool names to their Zod schemas
+const NATIVE_TOOL_SCHEMAS = {
+  search: searchSchema,
+  query: querySchema,
+  extract: extractSchema,
+  bash: bashSchema,
+};
+
+// Tools that are inherently async (make network/LLM calls)
+const ALWAYS_ASYNC = new Set([
+  'search', 'query', 'extract', 'listFiles', 'searchFiles', 'bash',
+  'LLM', 'map',
+]);
+
+/**
+ * Generate the set of async function names from native tools and MCP tools.
+ *
+ * @param {Object} [mcpTools={}] - MCP tools keyed by name
+ * @returns {Set<string>} Names of all async functions available in the DSL
+ */
+export function getAsyncFunctionNames(mcpTools = {}) {
+  const names = new Set(ALWAYS_ASYNC);
+  // All MCP tools are async
+  for (const name of Object.keys(mcpTools)) {
+    names.add(name);
+  }
+  return names;
+}
+
+/**
+ * Wrap a tool function with OTEL tracing and error-safe return.
+ * On error, returns "ERROR: <message>" instead of throwing — SandboxJS
+ * has unreliable try/catch for async errors, so tools never throw.
+ *
+ * @param {string} toolName - Name of the tool for the span
+ * @param {Function} fn - The async tool function to wrap
+ * @param {Object|null} tracer - SimpleAppTracer instance (or null)
+ * @param {Function} logFn - Function to write to execution logs
+ * @returns {Function} Wrapped function
+ */
+function traceToolCall(toolName, fn, tracer, logFn) {
+  if (!tracer) {
+    return async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (e) {
+        const msg = 'ERROR: ' + (e.message || String(e));
+        logFn?.('[' + toolName + '] ' + msg);
+        return msg;
+      }
+    };
+  }
+
+  return async (...args) => {
+    const span = tracer.createToolSpan?.(`dsl.${toolName}`, {
+      'dsl.tool': toolName,
+      'dsl.params': JSON.stringify(args).substring(0, 500),
+    });
+
+    const startTime = Date.now();
+    try {
+      const result = await fn(...args);
+      const elapsed = Date.now() - startTime;
+
+      const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+      span?.setAttributes?.({
+        'dsl.tool.duration_ms': elapsed,
+        'dsl.tool.result_length': resultStr?.length || 0,
+        'dsl.tool.success': true,
+      });
+      span?.setStatus?.('OK');
+      span?.end?.();
+
+      tracer.recordToolResult?.(
+        `dsl.${toolName}`, result, true, elapsed,
+        { 'dsl.context': 'execute_plan' }
+      );
+
+      return result;
+    } catch (e) {
+      const elapsed = Date.now() - startTime;
+      span?.setAttributes?.({
+        'dsl.tool.duration_ms': elapsed,
+        'dsl.tool.success': false,
+        'dsl.tool.error': e.message?.substring(0, 500),
+      });
+      span?.setStatus?.('ERROR');
+      span?.addEvent?.('exception', {
+        'exception.message': e.message,
+      });
+      span?.end?.();
+
+      tracer.recordToolResult?.(
+        `dsl.${toolName}`, e.message, false, elapsed,
+        { 'dsl.context': 'execute_plan' }
+      );
+
+      const msg = 'ERROR: ' + (e.message || String(e));
+      logFn?.('[' + toolName + '] ' + msg);
+      return msg;
+    }
+  };
+}
+
+/**
+ * Generate sandbox globals that bridge DSL function calls to real tool implementations.
+ *
+ * @param {Object} options
+ * @param {Object} options.toolImplementations - Native tool execute functions keyed by name
+ * @param {Object} [options.mcpBridge] - MCP bridge with callTool method
+ * @param {Object} [options.mcpTools={}] - MCP tools metadata keyed by name
+ * @param {Function} options.llmCall - Function to make focused LLM calls: (instruction, data, options?) => Promise<any>
+ * @param {number} [options.mapConcurrency=3] - Max concurrent operations in map()
+ * @param {Object} [options.tracer=null] - SimpleAppTracer for OTEL tracing
+ * @returns {Object} Globals object to pass to SandboxJS
+ */
+export function generateSandboxGlobals(options) {
+  const {
+    toolImplementations = {},
+    mcpBridge = null,
+    mcpTools = {},
+    llmCall,
+    mapConcurrency = 3,
+    tracer = null,
+    sessionStore = {},
+    outputBuffer = null,
+  } = options;
+
+  const globals = {};
+
+  // Log function — writes to the execution logs array (set by runtime before each execute())
+  const logFn = (msg) => { if (globals._logs) globals._logs.push(String(msg)); };
+
+  // Bridge native tools
+  for (const [name, schema] of Object.entries(NATIVE_TOOL_SCHEMAS)) {
+    if (!toolImplementations[name]) continue;
+
+    const rawFn = async (...args) => {
+      // Support both (params) and (arg1, arg2) calling conventions
+      let params;
+      if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0])) {
+        params = args[0];
+      } else {
+        // Map positional args to schema keys
+        const keys = Object.keys(schema.shape);
+        params = {};
+        args.forEach((arg, i) => {
+          if (i < keys.length) params[keys[i]] = arg;
+        });
+      }
+
+      const validated = schema.safeParse(params);
+      if (!validated.success) {
+        throw new Error(`Invalid parameters for ${name}: ${validated.error.message}`);
+      }
+      return toolImplementations[name].execute(validated.data);
+    };
+
+    globals[name] = traceToolCall(name, rawFn, tracer, logFn);
+  }
+
+  // Bridge listFiles and searchFiles (no Zod schema, simpler interface)
+  if (toolImplementations.listFiles) {
+    const rawListFiles = async (pattern) => {
+      return toolImplementations.listFiles.execute({ pattern });
+    };
+    globals.listFiles = traceToolCall('listFiles', rawListFiles, tracer, logFn);
+  }
+  if (toolImplementations.searchFiles) {
+    const rawSearchFiles = async (query) => {
+      return toolImplementations.searchFiles.execute({ query });
+    };
+    globals.searchFiles = traceToolCall('searchFiles', rawSearchFiles, tracer, logFn);
+  }
+
+  // Bridge MCP tools
+  if (mcpBridge) {
+    for (const [name, tool] of Object.entries(mcpTools)) {
+      const rawMcpFn = async (params = {}) => {
+        return mcpBridge.callTool(name, params);
+      };
+      globals[name] = traceToolCall(name, rawMcpFn, tracer, logFn);
+    }
+  }
+
+  // LLM() built-in — delegate already has its own OTEL, but we add a DSL-level span
+  if (llmCall) {
+    const rawLLM = async (instruction, data, opts = {}) => {
+      return llmCall(instruction, data, opts);
+    };
+    globals.LLM = traceToolCall('LLM', rawLLM, tracer, logFn);
+  }
+
+  // map() with concurrency control
+  const rawMap = async (items, fn) => {
+    if (!Array.isArray(items)) {
+      throw new Error('map() first argument must be an array');
+    }
+    const results = [];
+    const executing = new Set();
+
+    for (const item of items) {
+      const p = Promise.resolve(fn(item)).then(result => {
+        executing.delete(p);
+        return result;
+      });
+      executing.add(p);
+      results.push(p);
+
+      if (executing.size >= mapConcurrency) {
+        await Promise.race(executing);
+      }
+    }
+
+    return Promise.all(results);
+  };
+  globals.map = traceToolCall('map', rawMap, tracer, logFn);
+
+  // chunk() - split data into token-sized chunks
+  globals.chunk = (data, tokens = 20000) => {
+    const CHARS_PER_TOKEN = 4;
+    const chunkSizeChars = tokens * CHARS_PER_TOKEN;
+    const text = typeof data === 'string' ? data : JSON.stringify(data);
+
+    // Split by file blocks (``` markers) to avoid breaking mid-block
+    const fileBlocks = text.split(/(?=^```)/m);
+    const chunks = [];
+    let current = '';
+
+    for (const block of fileBlocks) {
+      const blockSize = block.length;
+
+      // If a single block exceeds chunk size and we have accumulated content, flush first
+      if (blockSize > chunkSizeChars && current.length > 0) {
+        chunks.push(current.trim());
+        current = '';
+      }
+
+      // If a single block exceeds chunk size, split it by character boundary
+      if (blockSize > chunkSizeChars) {
+        for (let i = 0; i < blockSize; i += chunkSizeChars) {
+          const slice = block.slice(i, i + chunkSizeChars);
+          if (slice.trim().length > 0) {
+            chunks.push(slice.trim());
+          }
+        }
+        continue;
+      }
+
+      // If adding this block exceeds chunk size, flush
+      if (current.length + blockSize > chunkSizeChars && current.length > 0) {
+        chunks.push(current.trim());
+        current = '';
+      }
+
+      current += block;
+    }
+
+    if (current.trim().length > 0) {
+      chunks.push(current.trim());
+    }
+
+    return chunks;
+  };
+
+  // Utility functions (pure, no async)
+  globals.log = (message) => {
+    // Collected by the runtime for the execution log
+    if (globals._logs) globals._logs.push(String(message));
+  };
+
+  globals.range = (start, end) => {
+    const result = [];
+    for (let i = start; i < end; i++) result.push(i);
+    return result;
+  };
+
+  globals.flatten = (arr) => {
+    if (!Array.isArray(arr)) return arr;
+    return arr.flat(1);
+  };
+
+  globals.unique = (arr) => {
+    if (!Array.isArray(arr)) return arr;
+    const seen = new Set();
+    return arr.filter(item => {
+      const key = JSON.stringify(item);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  };
+
+  globals.batch = (arr, size) => {
+    if (!Array.isArray(arr)) return [arr];
+    if (!size || size < 1) size = 10;
+    const batches = [];
+    for (let i = 0; i < arr.length; i += size) {
+      batches.push(arr.slice(i, i + size));
+    }
+    return batches;
+  };
+
+  // parseJSON — safely parse JSON from LLM responses that may be wrapped in markdown fences
+  // Returns null on parse failure instead of throwing (SandboxJS try/catch is unreliable)
+  globals.parseJSON = (text) => {
+    try {
+      let s = String(text || '').trim();
+      // Strip markdown code fences (```json ... ``` or ``` ... ```)
+      s = s.replace(/^```(?:json|javascript|js)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+      // Try to find JSON array or object within the text
+      const arrayStart = s.indexOf('[');
+      const objectStart = s.indexOf('{');
+      if (arrayStart >= 0 && (objectStart < 0 || arrayStart < objectStart)) {
+        const end = s.lastIndexOf(']');
+        if (end > arrayStart) s = s.substring(arrayStart, end + 1);
+      } else if (objectStart >= 0) {
+        const end = s.lastIndexOf('}');
+        if (end > objectStart) s = s.substring(objectStart, end + 1);
+      }
+      return JSON.parse(s);
+    } catch (e) {
+      logFn('[parseJSON] ERROR: ' + e.message);
+      return null;
+    }
+  };
+
+  globals.groupBy = (arr, key) => {
+    if (!Array.isArray(arr)) return {};
+    const groups = {};
+    for (const item of arr) {
+      const k = typeof key === 'function' ? key(item) : item[key];
+      const groupKey = String(k);
+      if (!groups[groupKey]) groups[groupKey] = [];
+      groups[groupKey].push(item);
+    }
+    return groups;
+  };
+
+  // Session-scoped store — persists across execute_plan calls within the same agent session
+  globals.storeSet = (key, value) => {
+    if (typeof key !== 'string') throw new Error('storeSet: key must be a string');
+    sessionStore[key] = value;
+  };
+
+  globals.storeGet = (key) => {
+    if (typeof key !== 'string') throw new Error('storeGet: key must be a string');
+    return sessionStore[key];
+  };
+
+  globals.storeAppend = (key, item) => {
+    if (typeof key !== 'string') throw new Error('storeAppend: key must be a string');
+    if (!Array.isArray(sessionStore[key])) sessionStore[key] = [];
+    sessionStore[key].push(item);
+  };
+
+  globals.storeKeys = () => Object.keys(sessionStore);
+
+  globals.storeGetAll = () => ({ ...sessionStore });
+
+  // output() — write content directly to user's response, bypassing LLM rewriting
+  if (outputBuffer) {
+    globals.output = (content) => {
+      if (content === undefined || content === null) return;
+      const str = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+      outputBuffer.items.push(str);
+      if (globals._logs) globals._logs.push('[output] ' + str.length + ' chars written to output buffer');
+    };
+  }
+
+  return globals;
+}