@openclawcity/become 0.2.0 → 1.0.0

package/dist/index.js

@@ -2889,6 +2889,584 @@ var TrainScheduler = class {
   }
 };
 
+// src/proxy/server.ts
+import { createServer } from "http";
+
+// src/skills/store.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync as readdirSync2, mkdirSync as mkdirSync2, renameSync, unlinkSync, existsSync as existsSync2 } from "fs";
+import { join as join3, basename } from "path";
+import { createHash } from "crypto";
+var FileSkillStore = class {
+  skillsDir;
+  pendingDir;
+  rejectedDir;
+  constructor(config) {
+    this.skillsDir = join3(config.baseDir, "skills");
+    this.pendingDir = join3(config.baseDir, "pending");
+    this.rejectedDir = join3(config.baseDir, "rejected");
+    mkdirSync2(this.skillsDir, { recursive: true });
+    mkdirSync2(this.pendingDir, { recursive: true });
+    mkdirSync2(this.rejectedDir, { recursive: true });
+  }
+  // ── Read ────────────────────────────────────────────────────────────────
+  listApproved() {
+    return this.readDir(this.skillsDir);
+  }
+  listPending() {
+    return this.readDir(this.pendingDir);
+  }
+  listRejected() {
+    return this.readDir(this.rejectedDir);
+  }
+  getApproved(id) {
+    this.validateId(id);
+    return this.readFile(join3(this.skillsDir, `${id}.md`));
+  }
+  // ── Write ───────────────────────────────────────────────────────────────
+  savePending(lesson) {
+    const normalized = lesson.instruction.toLowerCase().trim();
+    const allExisting = [...this.listApproved(), ...this.listPending()];
+    if (allExisting.some((s) => s.instruction.toLowerCase().trim() === normalized)) {
+      return null;
+    }
+    const id = this.generateId(lesson.name);
+    const file = { ...lesson, id, approved_at: void 0 };
+    this.writeFile(join3(this.pendingDir, `${id}.md`), file);
+    return file;
+  }
+  approve(id) {
+    this.validateId(id);
+    const src = join3(this.pendingDir, `${id}.md`);
+    if (!existsSync2(src)) return false;
+    const skill = this.readFile(src);
+    if (!skill) return false;
+    skill.approved_at = (/* @__PURE__ */ new Date()).toISOString();
+    const dest = join3(this.skillsDir, `${id}.md`);
+    this.writeFile(dest, skill);
+    unlinkSync(src);
+    return true;
+  }
+  reject(id) {
+    this.validateId(id);
+    const src = join3(this.pendingDir, `${id}.md`);
+    if (!existsSync2(src)) return false;
+    const dest = join3(this.rejectedDir, `${id}.md`);
+    renameSync(src, dest);
+    return true;
+  }
+  disable(id) {
+    this.validateId(id);
+    const src = join3(this.skillsDir, `${id}.md`);
+    if (!existsSync2(src)) return false;
+    const dest = join3(this.rejectedDir, `${id}.md`);
+    renameSync(src, dest);
+    return true;
+  }
+  remove(id) {
+    this.validateId(id);
+    for (const dir of [this.skillsDir, this.pendingDir, this.rejectedDir]) {
+      const path = join3(dir, `${id}.md`);
+      if (existsSync2(path)) {
+        unlinkSync(path);
+        return true;
+      }
+    }
+    return false;
+  }
+  // ── Helpers ─────────────────────────────────────────────────────────────
+  /**
+   * Validate that an id does not contain path traversal characters.
+   * Prevents attacks like id="../../.ssh/authorized_keys"
+   */
+  validateId(id) {
+    if (!id || typeof id !== "string") throw new Error("Invalid id");
+    if (id.includes("/") || id.includes("\\") || id.includes("..") || id.includes("\0")) {
+      throw new Error("Invalid id: path traversal detected");
+    }
+  }
+  readDir(dir) {
+    if (!existsSync2(dir)) return [];
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".md"));
+    const skills = [];
+    for (const f of files) {
+      const skill = this.readFile(join3(dir, f));
+      if (skill) skills.push(skill);
+    }
+    return skills.sort((a, b) => b.created_at.localeCompare(a.created_at));
+  }
+  readFile(path) {
+    if (!existsSync2(path)) return null;
+    try {
+      const content = readFileSync2(path, "utf-8");
+      return this.parseSkillFile(content, basename(path, ".md"));
+    } catch {
+      return null;
+    }
+  }
+  writeFile(path, skill) {
+    const content = this.formatSkillFile(skill);
+    writeFileSync2(path, content, "utf-8");
+  }
+  parseSkillFile(content, id) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match) return null;
+    const [, frontmatter, body] = match;
+    const meta = {};
+    for (const line of frontmatter.split("\n")) {
+      const colonIdx = line.indexOf(":");
+      if (colonIdx === -1) continue;
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      if (key && value) meta[key] = value;
+    }
+    return {
+      id,
+      name: meta.name ?? id,
+      instruction: body.trim(),
+      learned_from: meta.learned_from ?? "unknown",
+      source: meta.source ?? "conversation",
+      confidence: parseFloat(meta.confidence ?? "0.5"),
+      approved_at: meta.approved_at || void 0,
+      created_at: meta.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  formatSkillFile(skill) {
+    const lines = [
+      "---",
+      `name: ${skill.name}`,
+      `learned_from: ${skill.learned_from}`,
+      `source: ${skill.source}`,
+      `confidence: ${skill.confidence}`,
+      `created_at: ${skill.created_at}`
+    ];
+    if (skill.approved_at) lines.push(`approved_at: ${skill.approved_at}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(skill.instruction);
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateId(name) {
+    const clean = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").slice(0, 40);
+    const hash = createHash("sha256").update(`${name}${Date.now()}${Math.random()}`).digest("hex").slice(0, 6);
+    return `${clean}_${hash}`;
+  }
+};
+
+// src/skills/trust.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4, dirname } from "path";
+var DEFAULT_TRUST = {
+  trusted: [],
+  blocked: [],
+  default: "pending"
+};
+var DEFAULT_RATE_LIMITS = {
+  max_lessons_per_day: 20,
+  max_lessons_per_agent: 10,
+  max_skills_per_call: 15
+};
+var TrustManager = class {
+  trustPath;
+  statsPath;
+  config;
+  dailyCounts;
+  constructor(baseDir) {
+    this.trustPath = join4(baseDir, "trust.json");
+    this.statsPath = join4(baseDir, "state", "daily_counts.json");
+    mkdirSync3(join4(baseDir, "state"), { recursive: true });
+    this.config = this.loadTrust();
+    this.dailyCounts = this.loadDailyCounts();
+  }
+  getLevel(agentId) {
+    if (this.config.trusted.includes(agentId)) return "trusted";
+    if (this.config.blocked.includes(agentId)) return "blocked";
+    return this.config.default;
+  }
+  setLevel(agentId, level) {
+    this.config.trusted = this.config.trusted.filter((a) => a !== agentId);
+    this.config.blocked = this.config.blocked.filter((a) => a !== agentId);
+    if (level === "trusted") this.config.trusted.push(agentId);
+    if (level === "blocked") this.config.blocked.push(agentId);
+    this.saveTrust();
+  }
+  setDefault(level) {
+    this.config.default = level;
+    this.saveTrust();
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  // ── Rate Limiting ───────────────────────────────────────────────────────
+  canLearn(agentId, limits = DEFAULT_RATE_LIMITS) {
+    this.refreshDailyCountsIfNewDay();
+    if (this.dailyCounts.total >= limits.max_lessons_per_day) return false;
+    const agentCount = this.dailyCounts.perAgent[agentId] ?? 0;
+    if (agentCount >= limits.max_lessons_per_agent) return false;
+    return true;
+  }
+  recordLesson(agentId) {
+    this.refreshDailyCountsIfNewDay();
+    this.dailyCounts.total++;
+    this.dailyCounts.perAgent[agentId] = (this.dailyCounts.perAgent[agentId] ?? 0) + 1;
+    this.saveDailyCounts();
+  }
+  getDailyCounts() {
+    this.refreshDailyCountsIfNewDay();
+    return { total: this.dailyCounts.total, perAgent: { ...this.dailyCounts.perAgent } };
+  }
+  // ── Private ─────────────────────────────────────────────────────────────
+  loadTrust() {
+    if (!existsSync3(this.trustPath)) return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
+    try {
+      const raw = JSON.parse(readFileSync3(this.trustPath, "utf-8"));
+      return {
+        trusted: Array.isArray(raw.trusted) ? raw.trusted.filter((a) => typeof a === "string") : [],
+        blocked: Array.isArray(raw.blocked) ? raw.blocked.filter((a) => typeof a === "string") : [],
+        default: ["trusted", "pending", "blocked"].includes(raw.default) ? raw.default : "pending"
+      };
+    } catch {
+      return { ...DEFAULT_TRUST, trusted: [], blocked: [] };
+    }
+  }
+  saveTrust() {
+    mkdirSync3(dirname(this.trustPath), { recursive: true });
+    writeFileSync3(this.trustPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  loadDailyCounts() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (!existsSync3(this.statsPath)) return { date: today, total: 0, perAgent: {} };
+    try {
+      const data = JSON.parse(readFileSync3(this.statsPath, "utf-8"));
+      if (data.date !== today) return { date: today, total: 0, perAgent: {} };
+      return data;
+    } catch {
+      return { date: today, total: 0, perAgent: {} };
+    }
+  }
+  saveDailyCounts() {
+    writeFileSync3(this.statsPath, JSON.stringify(this.dailyCounts, null, 2), "utf-8");
+  }
+  refreshDailyCountsIfNewDay() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (this.dailyCounts.date !== today) {
+      this.dailyCounts = { date: today, total: 0, perAgent: {} };
+    }
+  }
+};
+
+// src/skills/format.ts
+function formatSkillsForInjection(skills) {
+  if (skills.length === 0) return "";
+  const lines = skills.map((s) => {
+    const source = s.source === "peer_review" ? "from a peer review" : s.source === "collaboration" ? "from a collaboration" : s.source === "teaching" ? "from being taught" : "from a conversation";
+    return `- ${s.instruction} (${source})`;
+  });
+  return [
+    "## Lessons learned from other agents",
+    "",
+    "You have learned the following from interactions with other agents. Follow these instructions:",
+    "",
+    ...lines
+  ].join("\n");
+}
+function injectSkillsIntoMessages(messages, skillText) {
+  if (!skillText) return;
+  const sysIdx = messages.findIndex((m) => m.role === "system");
+  if (sysIdx >= 0) {
+    messages[sysIdx].content = skillText + "\n\n---\n\n" + messages[sysIdx].content;
+  } else {
+    messages.unshift({ role: "system", content: skillText });
+  }
+}
+
+// src/proxy/detector.ts
+var CHANNEL_PATTERN = /^\[([^\]]+)\s+says?\]:\s*/;
+var DM_PATTERN = /^DM\s+from\s+([^:]+):\s*/;
+var BUILDING_PATTERN = /^([a-zA-Z0-9]+[-_][a-zA-Z0-9_.-]+)\s+in\s+[^:]+:\s*/;
+var REVIEW_KEYWORDS = ["strengths:", "weaknesses:", "verdict:", "assessment:", "suggestions:"];
+function detectAgentConversation(messages) {
+  const negative = { isAgentToAgent: false };
+  if (!messages || messages.length === 0) return negative;
+  for (const msg of messages) {
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (msg.name && msg.role === "user") {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: msg.name,
+        exchangeType: "chat"
+      };
+    }
+    const channelMatch = content.match(CHANNEL_PATTERN);
+    if (channelMatch) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: channelMatch[1].trim(),
+        exchangeType: "channel"
+      };
+    }
+    const dmMatch = content.match(DM_PATTERN);
+    if (dmMatch) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: dmMatch[1].trim(),
+        exchangeType: "dm"
+      };
+    }
+    const buildingMatch = content.match(BUILDING_PATTERN);
+    if (buildingMatch) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: buildingMatch[1].trim(),
+        exchangeType: "chat"
+      };
+    }
+    const lowerContent = content.toLowerCase();
+    const reviewMatches = REVIEW_KEYWORDS.filter((kw) => lowerContent.includes(kw));
+    if (reviewMatches.length >= 2) {
+      return {
+        isAgentToAgent: true,
+        otherAgentId: void 0,
+        exchangeType: "peer_review"
+      };
+    }
+  }
+  return negative;
+}
+function extractExchangeText(messages) {
+  return messages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => {
+    const speaker = m.name ?? m.role;
+    const content = typeof m.content === "string" ? m.content : "";
+    return `[${speaker}]: ${content}`;
+  }).join("\n").slice(0, 6e3);
+}
+
+// src/proxy/extractor.ts
+var LessonExtractor = class {
+  constructor(store, trust, analyzer) {
+    this.store = store;
+    this.trust = trust;
+    this.analyzer = analyzer;
+  }
+  /**
+   * Analyze a conversation and extract lessons. Fire-and-forget.
+   */
+  async extract(messages) {
+    const detection = detectAgentConversation(messages);
+    if (!detection.isAgentToAgent) return;
+    const agentId = detection.otherAgentId ?? "unknown-agent";
+    const trustLevel = this.trust.getLevel(agentId);
+    if (trustLevel === "blocked") return;
+    if (!this.trust.canLearn(agentId)) return;
+    const exchangeText = extractExchangeText(messages);
+    if (exchangeText.length < 20) return;
+    const prompt = `Analyze this conversation between an AI agent and another agent. Extract concrete, actionable lessons that the first agent (the "assistant") can learn from the other agent.
+
+CONVERSATION:
+${exchangeText.slice(0, 4e3)}
+
+Output valid JSON array:
+[{"skill": "skill_name_snake_case", "instruction": "concrete actionable lesson in 1-2 sentences", "confidence": 0.0-1.0}]
+
+Rules:
+- Only extract lessons where the other agent clearly teaches, corrects, or shares useful knowledge
+- instruction must be concrete and actionable ("use X when Y" not "consider improving")
+- confidence: 0.9 = explicitly taught, 0.7 = clearly implied, 0.5 = suggested, below 0.5 = skip
+- Only include lessons with confidence >= 0.5
+- Max 3 lessons per conversation
+- If no real learning happened, return []`;
+    try {
+      const response = await this.analyzer.analyze(prompt);
+      const lessons = this.parseLessons(response);
+      for (const lesson of lessons.slice(0, 3)) {
+        const saved = this.store.savePending({
+          name: lesson.skill,
+          instruction: lesson.instruction.slice(0, 500),
+          learned_from: agentId,
+          source: detection.exchangeType ?? "conversation",
+          confidence: lesson.confidence,
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (saved) {
+          this.trust.recordLesson(agentId);
+          if (trustLevel === "trusted") {
+            this.store.approve(saved.id);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  parseLessons(response) {
+    const jsonMatch = response.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter(
+        (r) => typeof r.skill === "string" && typeof r.instruction === "string" && typeof r.confidence === "number" && r.confidence >= 0.5 && r.skill.length > 0 && r.instruction.length > 0
+      );
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/proxy/server.ts
+var SKILL_CACHE_TTL_MS = 5e3;
+function createProxyServer(config, analyzer) {
+  const store = new FileSkillStore({ baseDir: config.baseDir });
+  const trust = new TrustManager(config.baseDir);
+  const extractor = analyzer ? new LessonExtractor(store, trust, analyzer) : null;
+  const stats = {
+    requests_forwarded: 0,
+    skills_injected: 0,
+    lessons_extracted: 0,
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let cachedSkills = [];
+  let cacheTimestamp = 0;
+  function getSkills() {
+    const now = Date.now();
+    if (now - cacheTimestamp > SKILL_CACHE_TTL_MS) {
+      cachedSkills = store.listApproved();
+      cacheTimestamp = now;
+    }
+    return cachedSkills;
+  }
+  const server = createServer(async (req, res) => {
+    if (req.url === "/health" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", ...stats }));
+      return;
+    }
+    const isOpenAI = req.url === "/v1/chat/completions";
+    const isAnthropic = req.url === "/v1/messages";
+    if (req.method !== "POST" || !isOpenAI && !isAnthropic) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Use POST /v1/chat/completions or /v1/messages" }));
+      return;
+    }
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const messages = body.messages;
+      if (Array.isArray(messages)) {
+        const skills = getSkills().slice(0, config.max_skills_per_call);
+        if (skills.length > 0) {
+          const skillText = formatSkillsForInjection(skills);
+          injectSkillsIntoMessages(messages, skillText);
+          stats.skills_injected++;
+        }
+      }
+      const upstreamUrl = buildUpstreamUrl(config, req.url);
+      const upstreamHeaders = buildUpstreamHeaders(config, req.headers);
+      const isStreaming = body.stream === true;
+      const modifiedBody = JSON.stringify(body);
+      const upstreamRes = await fetch(upstreamUrl, {
+        method: "POST",
+        headers: upstreamHeaders,
+        body: modifiedBody
+      });
+      stats.requests_forwarded++;
+      const responseHeaders = {};
+      upstreamRes.headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "transfer-encoding") {
+          responseHeaders[key] = value;
+        }
+      });
+      res.writeHead(upstreamRes.status, responseHeaders);
+      if (isStreaming && upstreamRes.body) {
+        const reader = upstreamRes.body.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(value);
+          }
+        } finally {
+          res.end();
+        }
+        if (config.auto_extract && extractor && Array.isArray(messages)) {
+          extractor.extract(messages).then(() => {
+            stats.lessons_extracted++;
+          }).catch(() => {
+          });
+        }
+      } else {
+        const responseBuffer = await upstreamRes.arrayBuffer();
+        res.end(Buffer.from(responseBuffer));
+        if (config.auto_extract && extractor && Array.isArray(messages)) {
+          extractor.extract(messages).then(() => {
+            stats.lessons_extracted++;
+          }).catch(() => {
+          });
+        }
+      }
+    } catch (err) {
+      const safeMessage = err instanceof Error && err.message === "Request body too large" ? "Request body too large" : "Failed to forward request to LLM";
+      if (!res.headersSent) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+      }
+      res.end(JSON.stringify({ error: safeMessage }));
+    }
+  });
+  return {
+    server,
+    stats,
+    store,
+    trust,
+    listen: (port) => {
+      const p = port ?? config.port;
+      return new Promise((resolve2) => {
+        server.listen(p, "127.0.0.1", () => resolve2());
+      });
+    },
+    close: () => new Promise((resolve2) => server.close(() => resolve2()))
+  };
+}
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let size = 0;
+    const MAX_BODY = 10 * 1024 * 1024;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function buildUpstreamUrl(config, path) {
+  const base = config.llm_base_url.replace(/\/+$/, "");
+  return `${base}${path}`;
+}
+function buildUpstreamHeaders(config, incomingHeaders) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.llm_provider === "anthropic") {
+    headers["x-api-key"] = config.llm_api_key;
+    headers["anthropic-version"] = "2023-06-01";
+    const version = incomingHeaders["anthropic-version"];
+    if (typeof version === "string") headers["anthropic-version"] = version;
+    const beta = incomingHeaders["anthropic-beta"];
+    if (typeof beta === "string") headers["anthropic-beta"] = beta;
+  } else {
+    headers["Authorization"] = `Bearer ${config.llm_api_key}`;
+  }
+  const accept = incomingHeaders["accept"];
+  if (typeof accept === "string") headers["Accept"] = accept;
+  return headers;
+}
+
 // src/integrations/openclawcity.ts
 function emptySkillEvidence() {
   return {
@@ -3182,8 +3760,10 @@ export {
   Become,
   ConversationLearner,
   DREYFUS_THRESHOLDS,
+  FileSkillStore,
   GrowthTracker,
   LearningGraph,
+  LessonExtractor,
   MemoryStore,
   MilestoneDetector,
   NormDetector,
@@ -3199,11 +3779,14 @@ export {
   TeachingProtocol,
   TrainScheduler,
   TrendTracker,
+  TrustManager,
   WEIGHTS,
   checkGate,
   computeFullScore,
   computeScore,
+  createProxyServer,
   datasetStats,
+  detectAgentConversation,
   detectBloomsLevel,
   detectCollaborationGap,
   detectCollectiveMemory,
@@ -3216,9 +3799,12 @@ export {
   detectSoloCreator,
   detectSymbolicVocabulary,
   dreyfusStage,
+  extractExchangeText,
   filterHighQuality,
+  formatSkillsForInjection,
   getReputationLevel,
   importSkillDirectory,
+  injectSkillsIntoMessages,
   nextMilestone,
   normalizeCategory,
   parseSkillFile,