dexbot 1.4.12 → 1.4.13

package/claw/modules/memu_bridge.ts

@@ -0,0 +1,505 @@
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+import { path } from '../../modules/path_api.js';
+import { getStorage } from '../../modules/storage/index.js';
+import { PATHS } from '../../modules/paths.js';
+import { runtime } from '../../modules/runtime.js';
+import { getErrorMessage } from '../../modules/utils/errors.js';
+import { Config } from '../../modules/config.js';
+const storage = getStorage();
+const { ensureDir, unlink: safeUnlink } = storage;
+
+let _spawn: any;
+function getSpawn(): any {
+    if (_spawn === undefined) {
+        try {
+            _spawn = require('child_process').spawn;
+        } catch {
+            _spawn = null;
+        }
+    }
+    if (!_spawn) {
+        throw new Error('child_process.spawn not available in this environment');
+    }
+    return _spawn;
+}
+
+const DEFAULT_MEMU_DIR = PATHS.CLAW.MEMU_DIR;
+const DEFAULT_PYTHON = Config.MEMU_PYTHON;
+
+function resolveMemuScript() {
+  const candidates = [
+    PATHS.CLAW.MEMU_RUNNER_SCRIPT,
+  ];
+
+  for (const candidate of candidates) {
+    if (storage.exists(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
+function ensureMemuDir(dir: any) {
+  if (!storage.exists(dir)) {
+    ensureDir(dir);
+  }
+  return dir;
+}
+
+function defaultDatabaseConfig(memuDir: any) {
+  return {
+    metadata_store: {
+      provider: 'sqlite',
+      dsn: `sqlite:///${path.join(memuDir, 'memu.db')}`
+    }
+  };
+}
+
+function normalizeScopeWhere(where = null, user = null) {
+  return where || user || null;
+}
+
+function runMemuPython(args: string[], options: Record<string, any> = {}) {
+  return new Promise((resolve, reject) => {
+    const python = options.python || DEFAULT_PYTHON;
+    const script = resolveMemuScript();
+    const timeout = options.timeout || 60000;
+
+    const child = getSpawn()(python, [script, ...args], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...runtime.env, ...options.env },
+      cwd: options.cwd
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk: any) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk: any) => {
+      stderr += chunk.toString();
+    });
+
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`memU operation timed out after ${timeout}ms`));
+    }, timeout);
+
+    child.on('close', (code: any) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`memU Python process exited with code ${code}: ${stderr.trim()}`));
+        return;
+      }
+
+      try {
+        const output = stdout.trim();
+        if (!output) {
+          resolve(null);
+          return;
+        }
+        const parsed = JSON.parse(output);
+        resolve(parsed);
+      } catch (error: any) {
+        reject(new Error(`Failed to parse memU output: ${getErrorMessage(error)}\nOutput: ${stdout.trim()}\nStderr: ${stderr.trim()}`));
+      }
+    });
+
+    child.on('error', (error: any) => {
+      clearTimeout(timer);
+      if (error.code === 'ENOENT') {
+        reject(new Error(`Python interpreter not found: ${python}. Set MEMU_PYTHON env var or install Python 3.13+.`));
+        return;
+      }
+      reject(error);
+    });
+
+    if (options.stdin) {
+      child.stdin.write(JSON.stringify(options.stdin));
+      child.stdin.end();
+    }
+  });
+}
+
+function createMemuBridge(options: Record<string, any> = {}) {
+  const memuDir = ensureMemuDir(options.memuDir || DEFAULT_MEMU_DIR);
+  const stateDir = ensureMemuDir(path.join(memuDir, 'state'));
+
+  const llmProfiles = options.llmProfiles || {};
+  const databaseConfig = options.databaseConfig || defaultDatabaseConfig(memuDir);
+
+  return {
+    memuDir,
+    stateDir,
+    llmProfiles,
+    databaseConfig,
+
+    async memorize(resourceUrl: any, modality: any, user: any = null) {
+      const args = [
+        'memorize',
+        '--resource-url', resourceUrl,
+        '--modality', modality,
+        '--memu-dir', memuDir,
+      ];
+
+      if (user) {
+        args.push('--user', JSON.stringify(user));
+      }
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args, { timeout: options.memorizeTimeout || 120000 });
+    },
+
+    async retrieve(queries: any, where: any = null, method: any = 'rag') {
+      const normalizedQueries = queries.map((q: any) => {
+        if (typeof q === 'string') {
+          return { role: 'user', content: { text: q } };
+        }
+        return q;
+      });
+
+      const args = [
+        'retrieve',
+        '--queries', JSON.stringify(normalizedQueries),
+        '--memu-dir', memuDir,
+        '--method', method
+      ];
+
+      if (where) {
+        args.push('--where', JSON.stringify(where));
+      }
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args, { timeout: options.retrieveTimeout || 60000 });
+    },
+
+    async listCategories(where = null) {
+      const args = [
+        'list-categories',
+        '--memu-dir', memuDir,
+      ];
+
+      if (where) {
+        args.push('--where', JSON.stringify(where));
+      }
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async listItems(where = null) {
+      const args = [
+        'list-items',
+        '--memu-dir', memuDir,
+      ];
+
+      if (where) {
+        args.push('--where', JSON.stringify(where));
+      }
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async createMemoryItem(categoryRef: any, summary: any, memoryType: any = 'knowledge', user: any = null) {
+      const args = [
+        'create-item',
+        '--category-id', categoryRef,
+        '--summary', summary,
+        '--memory-type', memoryType,
+        '--memu-dir', memuDir,
+      ];
+
+      if (user) {
+        args.push('--user', JSON.stringify(user));
+      }
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async updateMemoryItem(itemId: any, updates: any) {
+      const args = [
+        'update-item',
+        '--item-id', itemId,
+        '--updates', JSON.stringify(updates),
+        '--memu-dir', memuDir,
+      ];
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async deleteMemoryItem(itemId: any) {
+      const args = [
+        'delete-item',
+        '--item-id', itemId,
+        '--memu-dir', memuDir,
+      ];
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async clearMemory(where = null) {
+      const args = [
+        'clear',
+        '--memu-dir', memuDir,
+      ];
+
+      if (where) {
+        args.push('--where', JSON.stringify(where));
+      }
+
+      if (llmProfiles.default) {
+        args.push('--llm-profile', JSON.stringify(llmProfiles));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async getStatus(where = null) {
+      const args = [
+        'status',
+        '--memu-dir', memuDir,
+      ];
+
+      if (where) {
+        args.push('--where', JSON.stringify(where));
+      }
+
+      if (databaseConfig) {
+        args.push('--db-config', JSON.stringify(databaseConfig));
+      }
+
+      return runMemuPython(args);
+    },
+
+    async memorizeConversation(messages: any, user: any = null) {
+      const formatted = messages.map((m: any) => {
+        const role = m.role || 'user';
+        const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        return `[${role}]: ${content}`;
+      }).join('\n');
+
+      const tmpDir = path.join(memuDir, 'tmp');
+      if (!storage.exists(tmpDir)) {
+        ensureDir(tmpDir);
+      }
+      const tmpFile = path.join(tmpDir, `conv_${Date.now()}.txt`);
+      storage.writeFile(tmpFile, formatted);
+
+      try {
+        return await this.memorize(tmpFile, 'conversation', user);
+      } finally {
+        safeUnlink(tmpFile)
+      }
+    },
+
+    async memorizeTradingContext(context: any, user: any = null) {
+      const formatted = typeof context === 'string'
+        ? context
+        : JSON.stringify(context, null, 2);
+
+      const tmpDir = path.join(memuDir, 'tmp');
+      if (!storage.exists(tmpDir)) {
+        ensureDir(tmpDir);
+      }
+      const tmpFile = path.join(tmpDir, `trading_${Date.now()}.json`);
+      storage.writeFile(tmpFile, formatted);
+
+      try {
+        return await this.memorize(tmpFile, 'document', user);
+      } finally {
+        safeUnlink(tmpFile)
+      }
+    },
+
+    async retrieveTradingContext(query: any, user: any = null) {
+      const where: any = user ? { user_id: user.user_id || user } : null;
+      return this.retrieve(
+        [{ role: 'user', content: { text: query } }],
+        where,
+        'rag'
+      );
+    }
+  };
+}
+
+function describeMemuBridge(options: Record<string, any> = {}) {
+  return {
+    runtime: 'memu',
+    version: '0.1.0',
+    description: 'memU proactive memory integration for DEXBot2',
+    nativeIntegration: 'subprocess-bridge',
+    preferredTransport: 'local-cli-json-or-mcp',
+    skillFile: 'SKILL.md',
+    capabilities: [
+      'memorize-conversation',
+      'memorize-document',
+      'retrieve-memory',
+      'list-categories',
+      'list-items',
+      'create-memory-item',
+      'update-memory-item',
+      'delete-memory-item',
+      'clear-memory',
+      'memorize-trading-context',
+      'retrieve-trading-context'
+    ],
+    notes: 'memU provides 24/7 proactive memory for AI agents. It captures user intent, reduces LLM token costs, and enables context-aware trading assistance.',
+    requirements: {
+      python: '3.13+',
+      package: 'memu-py',
+      envVars: ['OPENAI_API_KEY', 'MEMU_PYTHON']
+    }
+  };
+}
+
+async function runMemuCommand(command: string, options: Record<string, any> = {}) {
+  const bridge = createMemuBridge(options);
+
+  switch (command) {
+    case 'manifest':
+      return describeMemuBridge(options);
+
+    case 'memorize': {
+      if (!options.resourceUrl || !options.modality) {
+        throw new Error('memorize requires resourceUrl and modality');
+      }
+      return bridge.memorize(options.resourceUrl, options.modality, options.user);
+    }
+
+    case 'retrieve': {
+      if (!options.queries) {
+        throw new Error('retrieve requires queries');
+      }
+      return bridge.retrieve(options.queries, options.where, options.method || 'rag');
+    }
+
+    case 'list-categories':
+      return bridge.listCategories(normalizeScopeWhere(options.where, options.user));
+
+    case 'list-items':
+      return bridge.listItems(normalizeScopeWhere(options.where, options.user));
+
+    case 'create-item': {
+      const categoryRef = options.categoryId || options.categoryName || options.category;
+      if (!categoryRef || !options.summary) {
+        throw new Error('create-item requires categoryId or categoryName, plus summary');
+      }
+      return bridge.createMemoryItem(
+        categoryRef,
+        options.summary,
+        options.memoryType || 'knowledge',
+        options.user
+      );
+    }
+
+    case 'update-item': {
+      if (!options.itemId || !options.updates) {
+        throw new Error('update-item requires itemId and updates');
+      }
+      return bridge.updateMemoryItem(options.itemId, options.updates);
+    }
+
+    case 'delete-item': {
+      if (!options.itemId) {
+        throw new Error('delete-item requires itemId');
+      }
+      return bridge.deleteMemoryItem(options.itemId);
+    }
+
+    case 'clear':
+      return bridge.clearMemory(normalizeScopeWhere(options.where, options.user));
+
+    case 'status':
+      return bridge.getStatus(normalizeScopeWhere(options.where, options.user));
+
+    case 'memorize-conversation': {
+      if (!options.messages) {
+        throw new Error('memorize-conversation requires messages array');
+      }
+      return bridge.memorizeConversation(options.messages, options.user);
+    }
+
+    case 'memorize-trading-context': {
+      if (!options.context) {
+        throw new Error('memorize-trading-context requires context');
+      }
+      return bridge.memorizeTradingContext(options.context, options.user);
+    }
+
+    case 'retrieve-trading-context': {
+      if (!options.query) {
+        throw new Error('retrieve-trading-context requires query');
+      }
+      return bridge.retrieveTradingContext(options.query, options.user);
+    }
+
+    default:
+      throw new Error(`Unsupported memU command: ${command}`);
+  }
+}
+
+export { createMemuBridge, describeMemuBridge, runMemuCommand, resolveMemuScript, DEFAULT_MEMU_DIR }
+

package/claw/modules/mpa_utils.ts

@@ -0,0 +1,31 @@
+'use strict';
+
+import { getAsset, getBackingAsset } from './chain_queries.js';
+
+const CORE_SYMBOL = 'BTS';
+
+async function requireBtsBackedMpa(mpaSymbolOrId: any) {
+  const mpaAsset = await getAsset(mpaSymbolOrId);
+  if (!mpaAsset) {
+    throw new Error(`Asset not found: ${mpaSymbolOrId}`);
+  }
+  if (!mpaAsset.bitasset_data_id) {
+    throw new Error(`${mpaSymbolOrId} is not a market-issued asset`);
+  }
+
+  const backingAsset = await getBackingAsset(mpaAsset.id);
+  if (!backingAsset) {
+    throw new Error(`Could not resolve backing asset for ${mpaSymbolOrId}`);
+  }
+  if (backingAsset.symbol !== CORE_SYMBOL) {
+    throw new Error(`${mpaAsset.symbol || mpaSymbolOrId} is backed by ${backingAsset.symbol}, not ${CORE_SYMBOL}`);
+  }
+
+  return {
+    backingAsset,
+    mpaAsset
+  };
+}
+
+export { CORE_SYMBOL, requireBtsBackedMpa }
+

package/claw/modules/position_discovery.ts

@@ -0,0 +1,163 @@
+/**
+ * Position Discovery
+ *
+ * Scans an account's on-chain call orders (debt positions) and returns
+ * normalized position objects that feed into the health assessor.
+ *
+ * This module discovers positions from the chain — it does not depend on
+ * PositionManager state files. It sees what actually exists on-chain.
+ */
+
+
+import { loadDexbotOrderUtils } from './dexbot_bridge.js';
+import { roundTo } from '../../modules/utils/math_utils.js';
+'use strict';
+
+import { getAsset, getBackingAsset, getBitassetData, getFullAccount } from './chain_queries.js';
+
+function getBlockchainToFloat() {
+  return loadDexbotOrderUtils().blockchainToFloat;
+}
+
+/**
+ * Compute BTS-per-MPA from settlement price.
+ */
+function computeBtsPerMpa(settlementPrice: any, mpaAsset: any, backingAsset: any) {
+  const base = settlementPrice?.base;
+  const quote = settlementPrice?.quote;
+  if (!base || !quote) return null;
+
+  const blockchainToFloat = getBlockchainToFloat();
+  const baseAmount = blockchainToFloat(
+    base.amount,
+    base.asset_id === mpaAsset.id ? mpaAsset.precision : backingAsset.precision
+  );
+  const quoteAmount = blockchainToFloat(
+    quote.amount,
+    quote.asset_id === mpaAsset.id ? mpaAsset.precision : backingAsset.precision
+  );
+  if (!baseAmount || !quoteAmount) return null;
+
+  if (base.asset_id === backingAsset.id && quote.asset_id === mpaAsset.id) {
+    return baseAmount / quoteAmount;
+  }
+  if (base.asset_id === mpaAsset.id && quote.asset_id === backingAsset.id) {
+    return quoteAmount / baseAmount;
+  }
+  return null;
+}
+
+/**
+ * Normalize a raw call order into a position object compatible with
+ * assessPosition() from position_health.ts.
+ *
+ * @param {Object} callOrder    – Raw call_order from get_full_accounts
+ * @param {Object} mpaAsset     – Resolved MPA asset object
+ * @param {Object} backingAsset – Resolved backing asset object
+ * @param {Object} bitassetData – Resolved bitasset data object
+ * @returns {Object} Normalized position
+ */
+function normalizeCallOrder(callOrder: any, mpaAsset: any, backingAsset: any, bitassetData: any) {
+  const blockchainToFloat = getBlockchainToFloat();
+  const debtAmount = blockchainToFloat(callOrder.debt, mpaAsset.precision);
+  const collateralAmount = blockchainToFloat(callOrder.collateral, backingAsset.precision);
+  const settlement = bitassetData?.current_feed?.settlement_price;
+  const btsPerMpa = computeBtsPerMpa(settlement, mpaAsset, backingAsset);
+  const debtValueInBts = debtAmount && btsPerMpa ? debtAmount * btsPerMpa : 0;
+  const collateralRatio = debtValueInBts > 0 ? collateralAmount / debtValueInBts : null;
+
+  return {
+    id: callOrder.id,
+    borrower: callOrder.borrower,
+    status: 'debt_open',
+    market: `${mpaAsset.symbol}/${backingAsset.symbol}`,
+    mpaSymbol: mpaAsset.symbol,
+    backingSymbol: backingAsset.symbol,
+    onChain: {
+      callOrderId: callOrder.id,
+      collateralAmount: collateralAmount || 0,
+      collateralRatio,
+      debtAmount: debtAmount || 0,
+      debtValueInBts,
+      btsPerMpa,
+      feedPublicationTime: bitassetData?.current_feed_publication_time || null,
+    },
+  };
+}
+
+/**
+ * Discover all debt positions for an account by scanning its call orders.
+ *
+ * @param {string} accountName – BitShares account name or ID
+ * @returns {Promise<Array>} Array of normalized position objects
+ */
+async function discoverPositions(accountName: string) {
+  const fullAccount = await getFullAccount(accountName);
+  if (!fullAccount) throw new Error(`Account not found: ${accountName}`);
+
+  const callOrders = Array.isArray(fullAccount.call_orders) ? fullAccount.call_orders : [];
+  if (callOrders.length === 0) return [] as any[];
+
+  // Collect unique debt asset IDs
+  const debtAssetIds = [...new Set(
+    callOrders.map((co: any) => co?.call_price?.quote?.asset_id).filter(Boolean)
+  )];
+
+  // Resolve all assets in parallel
+  const assetCache = new Map();
+  const bitassetCache = new Map();
+
+  for (const assetId of debtAssetIds) {
+    const mpaAsset = await getAsset(assetId);
+    if (!mpaAsset) continue;
+    assetCache.set(assetId, mpaAsset);
+
+    const backingAsset = await getBackingAsset(assetId);
+    if (backingAsset) assetCache.set(`backing:${assetId}`, backingAsset);
+
+    const bitassetData = await getBitassetData(assetId);
+    if (bitassetData) bitassetCache.set(assetId, bitassetData);
+  }
+
+  // Normalize each call order
+  const positions: any[] = [];
+  for (const callOrder of callOrders) {
+    const debtAssetId = callOrder?.call_price?.quote?.asset_id;
+    if (!debtAssetId) continue;
+
+    const mpaAsset = assetCache.get(debtAssetId);
+    const backingAsset = assetCache.get(`backing:${debtAssetId}`);
+    const bitassetData = bitassetCache.get(debtAssetId);
+    if (!mpaAsset || !backingAsset || !bitassetData) continue;
+
+    positions.push(normalizeCallOrder(callOrder, mpaAsset, backingAsset, bitassetData));
+  }
+
+  return positions;
+}
+
+/**
+ * Discover positions and return a summary suitable for quick inspection.
+ *
+ * @param {string} accountName – BitShares account name or ID
+ * @returns {Promise<Object>} { account, positionCount, discoveredAt, positions: [...summary] }
+ */
+async function discoverPositionsSummary(accountName: string) {
+  const positions = await discoverPositions(accountName);
+  return {
+    account: accountName,
+    positionCount: positions.length,
+    discoveredAt: new Date().toISOString(),
+    positions: positions.map(p => ({
+      id: p.id,
+      market: p.market,
+      debt: p.onChain.debtAmount,
+      collateral: p.onChain.collateralAmount,
+      cr: p.onChain.collateralRatio ? roundTo(p.onChain.collateralRatio, 1000) : null,
+      btsPerMpa: p.onChain.btsPerMpa ? roundTo(p.onChain.btsPerMpa, 10000) : null,
+    })),
+  };
+}
+
+export { discoverPositions, discoverPositionsSummary, normalizeCallOrder }
+