chainlesschain 0.45.75 → 0.45.77

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/gateways/ws/action-protocol.js

@@ -1,3 +1,55 @@
+export async function handleCoworkTask(server, id, ws, message) {
+  const { templateId = null, userMessage, files = [] } = message;
+
+  if (!userMessage || typeof userMessage !== "string") {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "INVALID_MESSAGE",
+      message: "userMessage field required",
+    });
+    return;
+  }
+
+  try {
+    const { runCoworkTask } = await import("../../lib/cowork-task-runner.js");
+
+    server._send(ws, {
+      id,
+      type: "cowork:started",
+      templateId,
+    });
+
+    const result = await runCoworkTask({
+      templateId,
+      userMessage,
+      files,
+      cwd: server.projectRoot || process.cwd(),
+      llmOptions: {},
+    });
+
+    server._send(ws, {
+      id,
+      type: "cowork:done",
+      taskId: result.taskId,
+      status: result.status,
+      templateId: result.templateId,
+      templateName: result.templateName,
+      summary: result.result?.summary || "",
+      artifacts: result.result?.artifacts || [],
+      toolsUsed: result.result?.toolsUsed || [],
+      iterationCount: result.result?.iterationCount || 0,
+    });
+  } catch (err) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "COWORK_FAILED",
+      message: err.message,
+    });
+  }
+}
+
 export function handleSlashCommand(server, id, ws, message) {
   const { sessionId, command } = message;
   const handler = server.sessionHandlers.get(sessionId);
@@ -36,7 +88,8 @@ export async function handleOrchestrate(server, id, ws, message) {
   }
 
   try {
-    const { Orchestrator, TASK_SOURCE } = await import("../../lib/orchestrator.js");
+    const { Orchestrator, TASK_SOURCE } =
+      await import("../../lib/orchestrator.js");
 
     const orch = new Orchestrator({
       cwd: cwd || server.projectRoot || process.cwd(),

package/src/gateways/ws/message-dispatcher.js

@@ -43,6 +43,7 @@ export function createWsMessageDispatcher(server) {
         "session-answer": () => server._handleSessionAnswer(id, ws, message),
         "host-tool-result": () => server._handleHostToolResult(id, ws, message),
         orchestrate: () => server._handleOrchestrate(id, ws, message),
+        "cowork-task": () => server._handleCoworkTask(id, ws, message),
         "tasks-list": () => server._handleTasksList(id, ws),
         "tasks-stop": () => server._handleTasksStop(id, ws, message),
         "tasks-detail": () => server._handleTaskDetail(id, ws, message),

package/src/gateways/ws/ws-server.js

@@ -48,7 +48,11 @@ import {
   handleTaskGraphAdvance,
   handleTaskGraphState,
 } from "./session-protocol.js";
-import { handleSlashCommand, handleOrchestrate } from "./action-protocol.js";
+import {
+  handleSlashCommand,
+  handleOrchestrate,
+  handleCoworkTask,
+} from "./action-protocol.js";
 import {
   handleWorktreeDiff,
   handleWorktreeMerge,
@@ -294,6 +298,11 @@ export class ChainlessChainWSServer extends EventEmitter {
     return handleOrchestrate(this, id, ws, message);
   }
 
+  /** @private — run a cowork daily task via SubAgentContext */
+  async _handleCoworkTask(id, ws, message) {
+    return handleCoworkTask(this, id, ws, message);
+  }
+
   /** @private – list background tasks */
   async _handleTasksList(id, ws) {
     try {

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 {

package/src/lib/cowork-task-runner.js

@@ -0,0 +1,101 @@
+/**
+ * Cowork Task Runner — executes daily tasks using SubAgentContext.
+ *
+ * Creates an isolated sub-agent with a template-specific system prompt,
+ * runs the agent loop, and yields progress events for WS consumers.
+ *
+ * @module cowork-task-runner
+ */
+
+import { SubAgentContext } from "./sub-agent-context.js";
+import { getTemplate } from "./cowork-task-templates.js";
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+const DEFAULT_MAX_ITERATIONS = 50;
+const DEFAULT_TOKEN_BUDGET = 100_000;
+
+// ─── Runner ───────────────────────────────────────────────────────────────────
+
+/**
+ * Run a cowork task using SubAgentContext.
+ *
+ * @param {object} options
+ * @param {string|null} options.templateId - Template ID (null = free mode)
+ * @param {string} options.userMessage - User's task description
+ * @param {string[]} [options.files] - File paths provided by user
+ * @param {string} [options.cwd] - Working directory
+ * @param {object} [options.db] - Database instance
+ * @param {object} [options.llmOptions] - LLM provider/model/key
+ * @param {number} [options.maxIterations] - Override iteration limit
+ * @param {number} [options.tokenBudget] - Override token budget
+ * @returns {Promise<{ taskId: string, status: string, result: object }>}
+ */
+export async function runCoworkTask(options = {}) {
+  const {
+    templateId = null,
+    userMessage,
+    files = [],
+    cwd = process.cwd(),
+    db = null,
+    llmOptions = {},
+    maxIterations = DEFAULT_MAX_ITERATIONS,
+    tokenBudget = DEFAULT_TOKEN_BUDGET,
+  } = options;
+
+  if (!userMessage || typeof userMessage !== "string") {
+    throw new Error("userMessage is required");
+  }
+
+  // Resolve template
+  const template = getTemplate(templateId);
+
+  // Build the task prompt with template context + files
+  const taskParts = [template.systemPromptExtension];
+
+  if (files.length > 0) {
+    taskParts.push(`\n## 用户提供的文件\n${files.join("\n")}`);
+  }
+
+  const task = taskParts.join("\n");
+
+  // Create isolated sub-agent context
+  const subAgent = SubAgentContext.create({
+    role: `cowork-${template.id}`,
+    task,
+    inheritedContext: null,
+    maxIterations,
+    tokenBudget,
+    db,
+    llmOptions,
+    cwd,
+  });
+
+  const taskId = subAgent.id;
+
+  // Run the agent with the user's message
+  try {
+    const result = await subAgent.run(userMessage);
+    return {
+      taskId,
+      status: subAgent.status,
+      templateId: template.id,
+      templateName: template.name,
+      result,
+    };
+  } catch (err) {
+    return {
+      taskId,
+      status: "failed",
+      templateId: template.id,
+      templateName: template.name,
+      result: {
+        summary: `Task failed: ${err.message}`,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: 0,
+      },
+    };
+  }
+}