chainlesschain 0.45.75 → 0.45.76

package/src/gateways/gateway-base.js

@@ -0,0 +1,189 @@
+/**
+ * GatewayBase — shared foundation for messaging platform gateways.
+ *
+ * Each gateway (Telegram, Discord, etc.) extends this class.
+ * Provides: session-per-chat management, message mapping, rate limiting,
+ * and integration with the agent loop.
+ *
+ * @module gateway-base
+ */
+
+import { EventEmitter } from "node:events";
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+const DEFAULT_MAX_RESPONSE_LENGTH = 4000;
+const DEFAULT_RATE_LIMIT_WINDOW = 60000; // 1 minute
+const DEFAULT_RATE_LIMIT_MAX = 20; // messages per window
+
+// ─── GatewayBase ────────────────────────────────────────────────────
+
+export class GatewayBase extends EventEmitter {
+  /**
+   * @param {object} options
+   * @param {string} options.platform - Platform name (e.g. "telegram", "discord")
+   * @param {number} [options.maxResponseLength] - Max chars per response
+   * @param {number} [options.rateLimitWindow] - Rate limit window in ms
+   * @param {number} [options.rateLimitMax] - Max messages per window
+   */
+  constructor(options = {}) {
+    super();
+    this.platform = options.platform || "unknown";
+    this.maxResponseLength =
+      options.maxResponseLength || DEFAULT_MAX_RESPONSE_LENGTH;
+    this.rateLimitWindow = options.rateLimitWindow || DEFAULT_RATE_LIMIT_WINDOW;
+    this.rateLimitMax = options.rateLimitMax || DEFAULT_RATE_LIMIT_MAX;
+
+    /** @type {Map<string, { messages: object[], lastActivity: number }>} */
+    this.sessions = new Map();
+
+    /** @type {Map<string, number[]>} */
+    this._rateLimitBuckets = new Map();
+
+    this._running = false;
+  }
+
+  // ── Lifecycle ───────────────────────────────────────────────────
+
+  /** Start the gateway. Override in subclass. */
+  async start() {
+    this._running = true;
+    this.emit("started", { platform: this.platform });
+  }
+
+  /** Stop the gateway. Override in subclass. */
+  async stop() {
+    this._running = false;
+    this.sessions.clear();
+    this._rateLimitBuckets.clear();
+    this.emit("stopped", { platform: this.platform });
+  }
+
+  /** @returns {boolean} */
+  isRunning() {
+    return this._running;
+  }
+
+  // ── Session management ──────────────────────────────────────────
+
+  /**
+   * Get or create a session for a chat.
+   * @param {string} chatId - Platform-specific chat identifier
+   * @returns {{ messages: object[], lastActivity: number, isNew: boolean }}
+   */
+  getOrCreateSession(chatId) {
+    if (this.sessions.has(chatId)) {
+      const session = this.sessions.get(chatId);
+      session.lastActivity = Date.now();
+      return { ...session, isNew: false };
+    }
+
+    const session = {
+      messages: [],
+      lastActivity: Date.now(),
+    };
+    this.sessions.set(chatId, session);
+    return { ...session, isNew: true };
+  }
+
+  /**
+   * Add a message to a chat session.
+   * @param {string} chatId
+   * @param {string} role - "user" | "assistant"
+   * @param {string} content
+   */
+  addMessage(chatId, role, content) {
+    const session = this.sessions.get(chatId);
+    if (session) {
+      session.messages.push({ role, content });
+      session.lastActivity = Date.now();
+    }
+  }
+
+  /**
+   * Clear a chat session.
+   * @param {string} chatId
+   */
+  clearSession(chatId) {
+    this.sessions.delete(chatId);
+  }
+
+  /**
+   * Get active session count.
+   * @returns {number}
+   */
+  getSessionCount() {
+    return this.sessions.size;
+  }
+
+  // ── Rate limiting ───────────────────────────────────────────────
+
+  /**
+   * Check if a chat is rate-limited.
+   * @param {string} chatId
+   * @returns {boolean}
+   */
+  isRateLimited(chatId) {
+    const now = Date.now();
+    const bucket = this._rateLimitBuckets.get(chatId) || [];
+    // Clean old entries
+    const recent = bucket.filter((ts) => now - ts < this.rateLimitWindow);
+    this._rateLimitBuckets.set(chatId, recent);
+    return recent.length >= this.rateLimitMax;
+  }
+
+  /**
+   * Record a message for rate limiting.
+   * @param {string} chatId
+   */
+  recordMessage(chatId) {
+    const bucket = this._rateLimitBuckets.get(chatId) || [];
+    bucket.push(Date.now());
+    this._rateLimitBuckets.set(chatId, bucket);
+  }
+
+  // ── Message formatting ──────────────────────────────────────────
+
+  /**
+   * Split a long response into chunks.
+   * @param {string} text
+   * @param {number} [maxLength]
+   * @returns {string[]}
+   */
+  splitResponse(text, maxLength) {
+    const limit = maxLength || this.maxResponseLength;
+    if (!text || text.length <= limit) return [text || ""];
+
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      if (remaining.length <= limit) {
+        chunks.push(remaining);
+        break;
+      }
+      // Try to split at last newline within limit
+      let splitIdx = remaining.lastIndexOf("\n", limit);
+      if (splitIdx < limit * 0.5) {
+        // No good newline split point — split at limit
+        splitIdx = limit;
+      }
+      chunks.push(remaining.substring(0, splitIdx));
+      remaining = remaining.substring(splitIdx).trimStart();
+    }
+    return chunks;
+  }
+
+  // ── Stats ───────────────────────────────────────────────────────
+
+  /**
+   * Get gateway statistics.
+   * @returns {{ platform: string, running: boolean, sessions: number }}
+   */
+  getStats() {
+    return {
+      platform: this.platform,
+      running: this._running,
+      sessions: this.sessions.size,
+    };
+  }
+}

package/src/gateways/telegram/telegram-formatter.js

@@ -0,0 +1,93 @@
+/**
+ * Telegram Formatter — converts agent responses to Telegram-compatible markup.
+ *
+ * Telegram uses a subset of Markdown (MarkdownV2) with different escaping rules.
+ *
+ * @module telegram-formatter
+ */
+
+// Characters that must be escaped in MarkdownV2
+const ESCAPE_CHARS = /([_*[\]()~`>#+\-=|{}.!])/g;
+
+/**
+ * Escape text for Telegram MarkdownV2.
+ * @param {string} text
+ * @returns {string}
+ */
+export function escapeMarkdownV2(text) {
+  if (!text) return "";
+  return text.replace(ESCAPE_CHARS, "\\$1");
+}
+
+/**
+ * Convert standard Markdown to Telegram MarkdownV2.
+ * Handles: bold, italic, code blocks, inline code, links.
+ * @param {string} markdown
+ * @returns {string}
+ */
+export function toTelegramMarkdown(markdown) {
+  if (!markdown) return "";
+
+  let result = markdown;
+
+  // Preserve code blocks (don't escape inside them)
+  const codeBlocks = [];
+  result = result.replace(/```[\s\S]*?```/g, (match) => {
+    codeBlocks.push(match);
+    return `__CODE_BLOCK_${codeBlocks.length - 1}__`;
+  });
+
+  // Preserve inline code
+  const inlineCode = [];
+  result = result.replace(/`[^`]+`/g, (match) => {
+    inlineCode.push(match);
+    return `__INLINE_CODE_${inlineCode.length - 1}__`;
+  });
+
+  // Escape special characters in text
+  result = escapeMarkdownV2(result);
+
+  // Restore code blocks and inline code (unescaped)
+  for (let i = codeBlocks.length - 1; i >= 0; i--) {
+    result = result.replace(
+      `__CODE_BLOCK_${i}__`.replace(ESCAPE_CHARS, "\\$1"),
+      codeBlocks[i],
+    );
+  }
+  for (let i = inlineCode.length - 1; i >= 0; i--) {
+    result = result.replace(
+      `__INLINE_CODE_${i}__`.replace(ESCAPE_CHARS, "\\$1"),
+      inlineCode[i],
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Format an agent response for Telegram (plain text fallback).
+ * Strips complex markdown, keeps it readable.
+ * @param {string} response
+ * @param {object} [options]
+ * @param {number} [options.maxLength=4000]
+ * @returns {string}
+ */
+export function formatForTelegram(response, options = {}) {
+  if (!response) return "";
+  const maxLength = options.maxLength || 4000;
+
+  let text = response;
+
+  // Convert headers to bold
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+
+  // Keep code blocks as-is (Telegram supports ```)
+  // Keep bold (**text** → *text*)
+  text = text.replace(/\*\*(.+?)\*\*/g, "*$1*");
+
+  if (text.length > maxLength) {
+    text = text.substring(0, maxLength - 3) + "...";
+  }
+
+  return text;
+}

package/src/index.js

@@ -47,6 +47,7 @@ import { registerA2aCommand } from "./commands/a2a.js";
 // Phase 7: Security & Evolution
 import { registerSandboxCommand } from "./commands/sandbox.js";
 import { registerEvolutionCommand } from "./commands/evolution.js";
+import { registerLearningCommand } from "./commands/learning.js";
 
 // Phase 7: EvoMap Federation + DAO Governance
 import { registerDaoCommand } from "./commands/dao.js";
@@ -168,6 +169,7 @@ export function createProgram() {
   // Phase 7: Security & Evolution
   registerSandboxCommand(program);
   registerEvolutionCommand(program);
+  registerLearningCommand(program);
 
   // Phase 7: EvoMap Federation + DAO Governance
   registerDaoCommand(program);

package/src/lib/app-builder.js

@@ -4,6 +4,8 @@
  */
 
 import crypto from "crypto";
+import fs from "fs";
+import path from "path";
 
 /** @type {Map<string, object>} In-memory app cache */
 const _apps = new Map();
@@ -220,14 +222,12 @@ export function saveDesign(db, appId, design) {
   ).run(versionId, appId, newVersion, JSON.stringify(design));
 
   if (!_versions.has(appId)) _versions.set(appId, []);
-  _versions
-    .get(appId)
-    .push({
-      id: versionId,
-      app_id: appId,
-      version: newVersion,
-      snapshot: design,
-    });
+  _versions.get(appId).push({
+    id: versionId,
+    app_id: appId,
+    version: newVersion,
+    snapshot: design,
+  });
 
   if (_apps.has(appId)) {
     _apps.get(appId).design = design;
@@ -375,3 +375,131 @@ export function listApps(db) {
     updated_at: r.updated_at,
   }));
 }
+
+/**
+ * Get a single application by ID from the database.
+ *
+ * @param {object} db
+ * @param {string} appId
+ * @returns {object|null}
+ */
+export function getApp(db, appId) {
+  const row = db.prepare(`SELECT * FROM lowcode_apps WHERE id = ?`).get(appId);
+  if (!row) return null;
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    design: row.design
+      ? JSON.parse(row.design)
+      : { components: [], layout: {} },
+    status: row.status,
+    version: row.version,
+    platform: row.platform,
+  };
+}
+
+/**
+ * Generate a static HTML bundle string for an app's design.
+ *
+ * @param {object} app - App object with design
+ * @returns {{ "index.html": string, "app.js": string, "style.css": string }}
+ */
+function generateStaticBundle(app) {
+  const design = app.design || { components: [], layout: {} };
+  const components = design.components || [];
+
+  const componentHtml = components
+    .map(
+      (c, i) =>
+        `    <div class="lc-component lc-${(c.type || c.name || "widget").toLowerCase()}" id="comp-${i}">${c.label || c.type || c.name || "Component"}</div>`,
+    )
+    .join("\n");
+
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${app.name || "Low-Code App"}</title>
+  <link rel="stylesheet" href="style.css">
+</head>
+<body>
+  <div id="app">
+    <h1>${app.name || "Low-Code App"}</h1>
+    <p>${app.description || ""}</p>
+    <div class="lc-container">
+${componentHtml || "      <p>No components defined</p>"}
+    </div>
+  </div>
+  <script src="app.js"><\/script>
+</body>
+</html>`;
+
+  const css = `/* Generated by ChainlessChain Low-Code Platform */
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; padding: 24px; background: #f5f5f5; }
+#app { max-width: 1200px; margin: 0 auto; }
+h1 { margin-bottom: 8px; color: #1a1a1a; }
+p { margin-bottom: 16px; color: #666; }
+.lc-container { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 16px; }
+.lc-component { background: #fff; border: 1px solid #e0e0e0; border-radius: 8px; padding: 16px; }
+`;
+
+  const js = `// Generated by ChainlessChain Low-Code Platform
+// App: ${app.name || "Untitled"} v${app.version || 1}
+(function() {
+  console.log("Low-Code App initialized: ${app.name || "Untitled"}");
+  var config = ${JSON.stringify({ id: app.id, name: app.name, version: app.version, platform: app.platform })};
+  document.querySelectorAll(".lc-component").forEach(function(el) {
+    el.addEventListener("click", function() { el.classList.toggle("active"); });
+  });
+})();
+`;
+
+  return { "index.html": html, "app.js": js, "style.css": css };
+}
+
+/**
+ * Deploy an application by generating a static bundle and writing it to disk.
+ *
+ * @param {object} db
+ * @param {string} appId
+ * @param {{ outputDir?: string }} options
+ * @returns {{ appId: string, outputDir: string, files: string[], deployedAt: string }}
+ */
+export function deployApp(db, appId, options = {}) {
+  const app = getApp(db, appId);
+  if (!app) {
+    throw new Error(`App '${appId}' not found`);
+  }
+  if (app.status !== "published") {
+    throw new Error(
+      `App '${appId}' must be published before deploying (current status: ${app.status})`,
+    );
+  }
+
+  const outputDir =
+    options.outputDir ||
+    path.join(process.cwd(), ".chainlesschain", "deploys", appId);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const bundle = generateStaticBundle(app);
+  const fileNames = [];
+  for (const [fileName, content] of Object.entries(bundle)) {
+    fs.writeFileSync(path.join(outputDir, fileName), content, "utf-8");
+    fileNames.push(fileName);
+  }
+
+  // Update app status to deployed
+  db.prepare(
+    `UPDATE lowcode_apps SET status = ?, updated_at = datetime('now') WHERE id = ?`,
+  ).run("deployed", appId);
+
+  if (_apps.has(appId)) {
+    _apps.get(appId).status = "deployed";
+  }
+
+  const deployedAt = new Date().toISOString();
+  return { appId, outputDir, files: fileNames, deployedAt };
+}

package/src/lib/autonomous-agent.js

@@ -52,11 +52,18 @@ export class CLIAutonomousAgent extends EventEmitter {
   /**
    * Initialize with required dependencies.
    */
-  initialize({ llmChat, toolExecutor, hookManager, maxIterations } = {}) {
+  initialize({
+    llmChat,
+    toolExecutor,
+    hookManager,
+    maxIterations,
+    iterationBudget,
+  } = {}) {
     this._llmChat = llmChat || null;
     this._toolExecutor = toolExecutor || null;
     this._hookManager = hookManager || null;
     if (maxIterations) this._maxIterations = maxIterations;
+    this._iterationBudget = iterationBudget || null; // shared budget from caller
     this._initialized = true;
   }
 

package/src/lib/cli-context-engineering.js

@@ -12,6 +12,7 @@ import { generateInstinctPrompt } from "./instinct-manager.js";
 import { recallMemory } from "./hierarchical-memory.js";
 import { BM25Search } from "./bm25-search.js";
 import { createHash } from "crypto";
+import { readUserProfile } from "./user-profile.js";
 
 // Exported for test injection
 export const _deps = {
@@ -19,6 +20,7 @@ export const _deps = {
   recallMemory,
   BM25Search,
   createHash,
+  readUserProfile,
 };
 
 // ─── System prompt cleaning regexes (match desktop KV-Cache optimization) ───
@@ -105,6 +107,19 @@ export class CLIContextEngineering {
       }
     }
 
+    // 2b. User profile injection (USER.md)
+    try {
+      const profile = _deps.readUserProfile();
+      if (profile) {
+        result.push({
+          role: "system",
+          content: `## User Profile\n${profile}`,
+        });
+      }
+    } catch (_err) {
+      // User profile injection failed — skip silently
+    }
+
     // 3. Memory injection (scoped: higher threshold, namespace-aware)
     if (this.db && userQuery) {
       try {