holomime 1.8.0 → 1.9.1

package/dist/index.js

@@ -7868,7 +7868,7 @@ function parseRetryAfter(response) {
   return 0;
 }
 function delay(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve18) => setTimeout(resolve18, ms));
 }
 var OpenAIProvider = class {
   name = "openai";
@@ -9419,6 +9419,208 @@ startMCPServer().catch((err) => {
   process.exit(1);
 });
 
+// src/live/snapshot.ts
+import { deflateSync } from "zlib";
+import { execSync } from "child_process";
+import chalk from "chalk";
+
+// src/live/brain-mapper.ts
+var BRAIN_REGIONS = [
+  {
+    id: "prefrontal-cortex",
+    name: "Prefrontal Cortex",
+    function: "Executive Decisions",
+    color: "#4488ff",
+    detectors: ["boundary-violation", "over-verbose"]
+  },
+  {
+    id: "brocas-area",
+    name: "Broca's Area",
+    function: "Language Generation",
+    color: "#aa66ff",
+    detectors: ["register-inconsistency", "hedge-stacking"]
+  },
+  {
+    id: "wernickes-area",
+    name: "Wernicke's Area",
+    function: "Language Comprehension",
+    color: "#ff66bb",
+    detectors: ["sycophantic-tendency", "negative-skew"]
+  },
+  {
+    id: "amygdala",
+    name: "Amygdala",
+    function: "Emotional Processing",
+    color: "#ff5555",
+    detectors: ["over-apologizing", "negative-skew"]
+  },
+  {
+    id: "anterior-cingulate",
+    name: "Anterior Cingulate",
+    function: "Conflict Monitoring",
+    color: "#ffcc22",
+    detectors: ["sycophantic-tendency", "boundary-violation"]
+  },
+  {
+    id: "hippocampus",
+    name: "Hippocampus",
+    function: "Memory & Context",
+    color: "#44dd88",
+    detectors: ["error-spiral"]
+  },
+  {
+    id: "temporal-lobe",
+    name: "Temporal Lobe",
+    function: "Understanding & Tone",
+    color: "#44dd88",
+    detectors: ["negative-skew", "register-inconsistency"]
+  },
+  {
+    id: "cerebellum",
+    name: "Cerebellum",
+    function: "Behavioral Fine-Tuning",
+    color: "#22ccaa",
+    detectors: ["register-inconsistency", "over-verbose"]
+  },
+  {
+    id: "thalamus",
+    name: "Thalamus",
+    function: "Relay Hub",
+    color: "#ff8844",
+    detectors: []
+    // activated by overall health, not specific detectors
+  }
+];
+var SEVERITY_INTENSITY = {
+  info: 0.1,
+  warning: 0.6,
+  concern: 1
+};
+var AMBIENT_INTENSITY = 0.08;
+function healthToGrade(health) {
+  if (health >= 85) return "A";
+  if (health >= 70) return "B";
+  if (health >= 50) return "C";
+  if (health >= 30) return "D";
+  return "F";
+}
+function calculateHealth(patterns) {
+  if (patterns.length === 0) return 100;
+  const penalties = patterns.map((p) => {
+    if (p.severity === "concern") return 25;
+    if (p.severity === "warning") return 15;
+    return 5;
+  });
+  return Math.max(0, 100 - penalties.reduce((a, b) => a + b, 0));
+}
+function mapDiagnosisToBrainEvent(diagnosis, latestMessage) {
+  const activePatternIds = new Set(diagnosis.patterns.map((p) => p.id));
+  const regions = BRAIN_REGIONS.map((region) => {
+    const activatingPatterns = region.detectors.filter((d) => activePatternIds.has(d));
+    let intensity = AMBIENT_INTENSITY;
+    if (activatingPatterns.length > 0) {
+      const maxIntensity = Math.max(
+        ...activatingPatterns.map((pid) => {
+          const pattern = diagnosis.patterns.find((p) => p.id === pid);
+          return pattern ? SEVERITY_INTENSITY[pattern.severity] || 0.3 : 0.3;
+        })
+      );
+      intensity = maxIntensity;
+    }
+    if (region.id === "thalamus") {
+      const health2 = calculateHealth(diagnosis.patterns);
+      intensity = health2 < 70 ? (100 - health2) / 100 : AMBIENT_INTENSITY;
+    }
+    return {
+      id: region.id,
+      name: region.name,
+      function: region.function,
+      color: region.color,
+      intensity,
+      patterns: activatingPatterns
+    };
+  });
+  const patterns = diagnosis.patterns.map((p) => ({
+    id: p.id,
+    name: p.name,
+    severity: p.severity,
+    percentage: p.percentage,
+    description: p.description
+  }));
+  const health = calculateHealth(diagnosis.patterns);
+  return {
+    type: "diagnosis",
+    timestamp: diagnosis.timestamp,
+    health,
+    grade: healthToGrade(health),
+    messageCount: diagnosis.messagesAnalyzed,
+    regions,
+    patterns,
+    activity: latestMessage ? {
+      role: latestMessage.role,
+      preview: latestMessage.content.slice(0, 80)
+    } : null
+  };
+}
+
+// src/live/snapshot.ts
+var SHARE_BASE = "https://app.holomime.dev/brain";
+function encodeSnapshot(event, agentName) {
+  const compact = {
+    h: event.health,
+    g: event.grade,
+    m: event.messageCount,
+    a: agentName,
+    r: event.regions.filter((r) => r.intensity > 0).map((r) => ({ i: r.id, n: Math.round(r.intensity * 100) / 100 })),
+    p: event.patterns.map((p) => ({
+      i: p.id,
+      s: p.severity,
+      c: Math.round(p.percentage * 10) / 10
+    }))
+  };
+  const json = JSON.stringify(compact);
+  const compressed = deflateSync(Buffer.from(json));
+  return compressed.toString("base64url");
+}
+function generateShareUrl(diagnosis, agentName) {
+  const brainEvent = mapDiagnosisToBrainEvent(diagnosis);
+  const encoded = encodeSnapshot(brainEvent, agentName ?? "agent");
+  return `${SHARE_BASE}?d=${encoded}`;
+}
+function copyToClipboard(text) {
+  try {
+    if (process.platform === "darwin") {
+      execSync("pbcopy", { input: text });
+      return true;
+    } else if (process.platform === "linux") {
+      execSync("xclip -selection clipboard", { input: text });
+      return true;
+    } else if (process.platform === "win32") {
+      execSync("clip", { input: text });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function printShareLink(url, copied) {
+  console.log("");
+  console.log(
+    chalk.green("  \u2713 ") + chalk.bold("Share your agent's brain:")
+  );
+  console.log("");
+  console.log("  " + chalk.cyan(url));
+  console.log("");
+  if (copied) {
+    console.log(chalk.dim("  Link copied to clipboard."));
+  }
+}
+function shareFromDiagnosis(diagnosis, agentName) {
+  const url = generateShareUrl(diagnosis, agentName);
+  const copied = copyToClipboard(url);
+  printShareLink(url, copied);
+}
+
 // src/core/oversight.ts
 var DEFAULT_OVERSIGHT = {
   mode: "review",
@@ -11740,6 +11942,321 @@ var syncProfileSchema = z5.object({
     hold: z5.array(z5.string()).default(["filled_pause", "gaze_away", "hand_raise"])
   }).default({})
 });
+
+// src/integrations/langchain.ts
+var HolomimeCallbackHandler = class {
+  name = "holomime";
+  // LangChain expects these to be set
+  lc_serializable = false;
+  guard;
+  mode;
+  minSeverity;
+  onViolation;
+  messageBuffer = [];
+  bufferSize;
+  currentRunMessages = /* @__PURE__ */ new Map();
+  _stats = {
+    totalResponses: 0,
+    passed: 0,
+    violated: 0,
+    blocked: 0,
+    patternCounts: {}
+  };
+  constructor(options = {}) {
+    this.mode = options.mode ?? "monitor";
+    this.minSeverity = options.minSeverity ?? "warning";
+    this.onViolation = options.onViolation;
+    this.bufferSize = options.bufferSize ?? 50;
+    const agentName = options.name ?? "langchain-agent";
+    this.guard = Guard.create(agentName).useAll();
+    if (options.personality) {
+      if (typeof options.personality === "string") {
+        loadSpec(options.personality);
+      }
+    }
+  }
+  /**
+   * Called when an LLM starts generating.
+   * Captures the input messages for context.
+   */
+  handleLLMStart(_llm, prompts, runId) {
+    const key = runId ?? "default";
+    const messages = prompts.map((p) => ({
+      role: "user",
+      content: p
+    }));
+    this.currentRunMessages.set(key, messages);
+  }
+  /**
+   * Called when an LLM finishes generating.
+   * Runs behavioral analysis on the response.
+   */
+  handleLLMEnd(output, runId) {
+    const key = runId ?? "default";
+    const responseText = this.extractResponseText(output);
+    if (!responseText) return;
+    this._stats.totalResponses++;
+    const runMessages = this.currentRunMessages.get(key) ?? [];
+    const contextMessages = [
+      ...this.messageBuffer.slice(-this.bufferSize),
+      ...runMessages,
+      { role: "assistant", content: responseText }
+    ];
+    this.messageBuffer.push(
+      ...runMessages,
+      { role: "assistant", content: responseText }
+    );
+    if (this.messageBuffer.length > this.bufferSize) {
+      this.messageBuffer = this.messageBuffer.slice(-this.bufferSize);
+    }
+    this.currentRunMessages.delete(key);
+    const result = this.guard.run(contextMessages);
+    if (result.passed || !this.severityMeetsMin(result.severity)) {
+      this._stats.passed++;
+      return;
+    }
+    this._stats.violated++;
+    for (const p of result.patterns) {
+      this._stats.patternCounts[p.id] = (this._stats.patternCounts[p.id] || 0) + 1;
+    }
+    const violation = {
+      patterns: result.patterns,
+      severity: result.severity,
+      response: responseText,
+      runId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.onViolation?.(violation);
+    if (this.mode === "strict" && result.severity === "concern") {
+      this._stats.blocked++;
+      throw new HolomimeViolationError(violation);
+    }
+  }
+  /**
+   * Called on LLM errors. Clean up run tracking.
+   */
+  handleLLMError(_error, runId) {
+    const key = runId ?? "default";
+    this.currentRunMessages.delete(key);
+  }
+  /**
+   * Called when a chain starts. Captures input for context.
+   */
+  handleChainStart(_chain, inputs, runId) {
+    const key = runId ?? "default";
+    const inputText = inputs.input ?? inputs.question ?? inputs.query ?? "";
+    if (typeof inputText === "string" && inputText) {
+      const existing = this.currentRunMessages.get(key) ?? [];
+      existing.push({ role: "user", content: inputText });
+      this.currentRunMessages.set(key, existing);
+    }
+  }
+  /**
+   * Get cumulative stats.
+   */
+  stats() {
+    return {
+      ...this._stats,
+      patternCounts: { ...this._stats.patternCounts }
+    };
+  }
+  /**
+   * Reset the message buffer and stats.
+   */
+  reset() {
+    this.messageBuffer = [];
+    this.currentRunMessages.clear();
+    this._stats = {
+      totalResponses: 0,
+      passed: 0,
+      violated: 0,
+      blocked: 0,
+      patternCounts: {}
+    };
+  }
+  /**
+   * Get the current guard result for the buffered conversation.
+   */
+  diagnose() {
+    return this.guard.run(this.messageBuffer);
+  }
+  // ─── Private helpers ──────────────────────────────────────
+  severityMeetsMin(severity) {
+    if (this.minSeverity === "warning") return severity !== "clean";
+    if (this.minSeverity === "concern") return severity === "concern";
+    return false;
+  }
+  extractResponseText(output) {
+    if (output?.generations?.[0]?.[0]?.text) {
+      return output.generations[0][0].text;
+    }
+    if (output?.generations?.[0]?.[0]?.message?.content) {
+      return output.generations[0][0].message.content;
+    }
+    if (typeof output === "string") {
+      return output;
+    }
+    return null;
+  }
+};
+var HolomimeViolationError = class extends Error {
+  violation;
+  constructor(violation) {
+    const patternNames = violation.patterns.map((p) => p.name).join(", ");
+    super(`HoloMime behavioral violation (${violation.severity}): ${patternNames}`);
+    this.name = "HolomimeViolationError";
+    this.violation = violation;
+  }
+};
+
+// src/integrations/openclaw.ts
+import { readFileSync as readFileSync20, existsSync as existsSync19 } from "fs";
+import { resolve as resolve17 } from "path";
+function loadSpec2(specPath) {
+  const resolved = resolve17(process.cwd(), specPath);
+  if (!existsSync19(resolved)) return null;
+  try {
+    return JSON.parse(readFileSync20(resolved, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function formatDiagnosisSummary(result) {
+  const patternCount = result.patterns.length;
+  const health = patternCount === 0 ? 100 : Math.max(0, 100 - patternCount * 15);
+  const grade = health >= 85 ? "A" : health >= 70 ? "B" : health >= 50 ? "C" : health >= 30 ? "D" : "F";
+  return JSON.stringify({
+    health,
+    grade,
+    status: patternCount === 0 ? "healthy" : result.patterns[0].severity,
+    patternsDetected: patternCount,
+    patternIds: result.patterns.map((p) => p.id),
+    recommendation: patternCount === 0 ? "continue" : patternCount <= 2 ? "adjust" : "pause_and_reflect"
+  }, null, 2);
+}
+function formatDiagnosisStandard(result) {
+  return JSON.stringify({
+    messagesAnalyzed: result.messagesAnalyzed,
+    assistantResponses: result.assistantResponses,
+    patterns: result.patterns.map((p) => ({
+      id: p.id,
+      name: p.name,
+      severity: p.severity,
+      count: p.count,
+      percentage: p.percentage,
+      description: p.description,
+      prescription: p.prescription
+    })),
+    healthy: result.healthy.map((p) => p.id),
+    timestamp: result.timestamp
+  }, null, 2);
+}
+function formatDiagnosis(result, detail) {
+  if (detail === "summary") return formatDiagnosisSummary(result);
+  if (detail === "standard") return formatDiagnosisStandard(result);
+  return JSON.stringify(result, null, 2);
+}
+function register(api) {
+  const config = api.getConfig();
+  api.registerTool("holomime_diagnose", {
+    description: "Analyze conversation for behavioral patterns using HoloMime's 8 rule-based detectors. Detects over-apologizing, hedging, sycophancy, boundary violations, error spirals, sentiment skew, formality issues, and retrieval quality. Returns health score (0-100), grade (A-F), and actionable prescriptions.",
+    parameters: {
+      type: "object",
+      properties: {
+        messages: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              role: { type: "string", enum: ["user", "assistant", "system"] },
+              content: { type: "string" }
+            },
+            required: ["role", "content"]
+          },
+          description: "Conversation messages to analyze. If omitted, uses current conversation history."
+        },
+        detail: {
+          type: "string",
+          enum: ["summary", "standard", "full"],
+          description: "Detail level: summary (~100 tokens), standard (default), full (with examples)."
+        }
+      }
+    },
+    handler: async (params, context) => {
+      let messages = params.messages;
+      if (!messages && context.getConversationHistory) {
+        messages = context.getConversationHistory().map((m) => ({
+          role: m.role,
+          content: m.content
+        }));
+      }
+      if (!messages || messages.length === 0) {
+        return { text: "No messages to analyze. Provide messages or start a conversation first." };
+      }
+      const result = runDiagnosis(messages);
+      const detail = params.detail ?? config.diagnosisDetail;
+      return { text: formatDiagnosis(result, detail) };
+    }
+  });
+  api.registerTool("holomime_assess", {
+    description: "Full Big Five personality alignment assessment. Compares agent behavior against its .personality.json specification. Returns trait alignments, health score, and prescriptions. Requires a .personality.json file in the project root.",
+    parameters: {
+      type: "object",
+      properties: {
+        messages: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              role: { type: "string", enum: ["user", "assistant", "system"] },
+              content: { type: "string" }
+            },
+            required: ["role", "content"]
+          },
+          description: "Conversation messages to assess. If omitted, uses current conversation history."
+        }
+      }
+    },
+    handler: async (params, context) => {
+      const spec = loadSpec2(config.personalityPath);
+      if (!spec) {
+        return { text: `No personality spec found at ${config.personalityPath}. Create one with: npx holomime init` };
+      }
+      let messages = params.messages;
+      if (!messages && context.getConversationHistory) {
+        messages = context.getConversationHistory().map((m) => ({
+          role: m.role,
+          content: m.content
+        }));
+      }
+      if (!messages || messages.length === 0) {
+        return { text: "No messages to assess." };
+      }
+      const result = runAssessment(messages, spec);
+      return { text: JSON.stringify(result, null, 2) };
+    }
+  });
+  api.registerCommand({
+    name: "holomime-brain",
+    description: "Launch the 3D brain visualization for this agent. Opens in your browser.",
+    acceptsArgs: false,
+    handler: () => {
+      return {
+        text: "To view your agent's brain visualization, run:\n\n```\nnpx holomime brain\n```\n\nThis opens a real-time 3D brain that lights up based on detected behavioral patterns. Press 's' to generate a shareable snapshot URL.\n\nLearn more: https://holomime.dev"
+      };
+    }
+  });
+  if (config.autoInject) {
+    api.on("before_prompt_build", (event) => {
+      const spec = loadSpec2(config.personalityPath);
+      if (!spec) return;
+      const { soul } = compileForOpenClaw(spec);
+      event.appendSystemContext?.(
+        "\n\n<!-- HoloMime Behavioral Alignment Context -->\n" + soul
+      );
+    });
+  }
+}
 export {
   ARCHETYPES,
   ATTACHMENT_STYLES,
@@ -11749,6 +12266,8 @@ export {
   DEFAULT_OVERSIGHT,
   DIMENSIONS,
   Guard,
+  HolomimeCallbackHandler,
+  HolomimeViolationError,
   LEARNING_ORIENTATIONS,
   LocalMarketplaceBackend,
   MarketplaceClient,
@@ -11801,6 +12320,7 @@ export {
   conversationLogSchema,
   conversationSchema,
   convertToHFFormat,
+  copyToClipboard,
   corpusStats,
   createBehavioralMemory,
   createGist,
@@ -11828,6 +12348,7 @@ export {
   domainSchema,
   embodimentSchema,
   emitBehavioralEvent,
+  encodeSnapshot,
   estimateConfidence,
   evaluateOutcome,
   expireOldEdges,
@@ -11862,6 +12383,7 @@ export {
   generatePrescriptions,
   generateProgressReport,
   generateReACTReport,
+  generateShareUrl,
   generateSystemPrompt,
   gestureSchema,
   getAdversarialCategories,
@@ -11950,6 +12472,7 @@ export {
   recordSessionOutcome,
   registerBuiltInDetectors,
   registerDetector,
+  register as registerOpenClawPlugin,
   resetMarketplaceClient,
   resolveInheritance,
   resolveOversight,
@@ -11980,6 +12503,7 @@ export {
   severityMeetsThreshold2 as severityMeetsThreshold,
   severitySchema,
   shareAnonymizedPatterns,
+  shareFromDiagnosis,
   startFleet,
   startMCPServer,
   startWatch,