nexo-brain 0.1.2 → 0.2.0

package/README.md

@@ -239,6 +239,67 @@ NEXO isn't just engineering — it's applied cognitive psychology:
 | Synaptic Pruning | Automated cleanup of weak, unused memories |
 | Associative Memory | Semantic search finds related concepts, not just matching words |
 
+## OpenClaw Integration
+
+NEXO Brain works as a cognitive memory backend for [OpenClaw](https://github.com/openclaw/openclaw). Three integration paths, from instant to deep:
+
+### Path 1: MCP Bridge (Zero Code — Works Now)
+
+Add NEXO Brain to your OpenClaw config at `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "nexo-brain": {
+        "command": "python3",
+        "args": ["~/.nexo/src/server.py"],
+        "env": {
+          "NEXO_HOME": "~/.nexo"
+        }
+      }
+    }
+  }
+}
+```
+
+Or via CLI:
+
+```bash
+openclaw mcp set nexo-brain '{"command":"python3","args":["~/.nexo/src/server.py"],"env":{"NEXO_HOME":"~/.nexo"}}'
+openclaw gateway restart
+```
+
+All 76 NEXO tools become available to your OpenClaw agent immediately.
+
+> **First time?** Run `npx nexo-brain` first to install the cognitive engine and dependencies.
+
+### Path 2: ClawHub Skill (Install in Seconds)
+
+```bash
+npx clawhub@latest install nexo-brain
+```
+
+### Path 3: Native Memory Plugin (Replaces Default Memory)
+
+```bash
+npm install @wazionapps/openclaw-memory-nexo-brain
+```
+
+Configure in `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "slots": {
+      "memory": "memory-nexo-brain"
+    }
+  }
+}
+```
+
+This replaces OpenClaw's default memory system with NEXO's full cognitive architecture — Atkinson-Shiffrin memory, semantic RAG, trust scoring, guard system, and all 76 tools.
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines. Issues and PRs welcome.

package/bin/nexo-brain 2.js

@@ -0,0 +1,610 @@
+#!/usr/bin/env node
+/**
+ * create-nexo — Interactive installer for NEXO cognitive co-operator.
+ *
+ * Usage: npx create-nexo
+ *
+ * What it does:
+ * 1. Asks for the co-operator's name
+ * 2. Asks permission to scan the workspace
+ * 3. Installs Python dependencies (fastembed, numpy, mcp)
+ * 4. Creates ~/.nexo/ with DB, personality, and config
+ * 5. Configures Claude Code MCP settings
+ * 6. Creates LaunchAgents for macOS automated processes
+ * 7. Generates CLAUDE.md with the operator's instructions
+ */
+
+const { execSync, spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+const NEXO_HOME = path.join(require("os").homedir(), ".nexo");
+const CLAUDE_SETTINGS = path.join(
+  require("os").homedir(),
+  ".claude",
+  "settings.json"
+);
+const LAUNCH_AGENTS = path.join(
+  require("os").homedir(),
+  "Library",
+  "LaunchAgents"
+);
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function run(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { encoding: "utf8", stdio: "pipe", ...opts }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+async function main() {
+  console.log("");
+  console.log(
+    "  ╔══════════════════════════════════════════════════════════╗"
+  );
+  console.log(
+    "  ║  NEXO — Cognitive Co-Operator for Claude Code          ║"
+  );
+  console.log(
+    "  ║  Atkinson-Shiffrin Memory | RAG | Trust Score           ║"
+  );
+  console.log(
+    "  ╚══════════════════════════════════════════════════════════╝"
+  );
+  console.log("");
+
+  // Check prerequisites
+  const platform = process.platform;
+  if (platform !== "darwin") {
+    log("NEXO currently supports macOS only. Linux support coming soon.");
+    process.exit(1);
+  }
+
+  // Find or install Homebrew (needed for Python)
+  let hasBrew = run("which brew");
+  if (!hasBrew) {
+    log("Homebrew not found. Installing...");
+    spawnSync("/bin/bash", ["-c", '$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)'], {
+      stdio: "inherit",
+    });
+    hasBrew = run("which brew") || run("eval $(/opt/homebrew/bin/brew shellenv) && which brew");
+  }
+
+  // Find or install Python
+  let python = run("which python3");
+  if (!python) {
+    if (hasBrew) {
+      log("Python 3 not found. Installing via Homebrew...");
+      spawnSync("brew", ["install", "python3"], { stdio: "inherit" });
+      python = run("which python3");
+    }
+    if (!python) {
+      log("Python 3 not found and couldn't install automatically.");
+      log("Install it manually: brew install python3");
+      process.exit(1);
+    }
+  }
+  const pyVersion = run(`${python} --version`);
+  log(`Found ${pyVersion} at ${python}`);
+
+  // Find or install Claude Code
+  let claudeInstalled = run("which claude");
+  if (!claudeInstalled) {
+    log("Claude Code not found. Installing...");
+    const npmInstall = spawnSync("npm", ["install", "-g", "@anthropic-ai/claude-code"], {
+      stdio: "inherit",
+    });
+    claudeInstalled = run("which claude");
+    if (!claudeInstalled) {
+      log("Could not install Claude Code automatically.");
+      log("Install it manually: npm install -g @anthropic-ai/claude-code");
+      process.exit(1);
+    }
+    log("Claude Code installed successfully.");
+  } else {
+    log("Claude Code detected.");
+  }
+  console.log("");
+
+  // Step 1: Name
+  const name = await ask("  How should I call myself? (default: NEXO) > ");
+  const operatorName = name.trim() || "NEXO";
+  log(`Got it. I'm ${operatorName}.`);
+  console.log("");
+
+  // Step 2: Permission to scan
+  const scanAnswer = await ask(
+    "  Can I explore your workspace to learn about your projects? (y/n) > "
+  );
+  const doScan = scanAnswer.trim().toLowerCase().startsWith("y");
+  console.log("");
+
+  // Step 2b: Keep Mac awake for nocturnal processes?
+  const caffeinateAnswer = await ask(
+    "  Keep Mac awake so my cognitive processes run on schedule? (y/n) > "
+  );
+  const doCaffeinate = caffeinateAnswer.trim().toLowerCase().startsWith("y");
+  console.log("");
+
+  // Step 3: Install Python dependencies
+  log("Installing cognitive engine dependencies...");
+  const pipInstall = spawnSync(
+    python,
+    [
+      "-m",
+      "pip",
+      "install",
+      "--quiet",
+      "fastembed",
+      "numpy",
+      "mcp[cli]",
+    ],
+    { stdio: "inherit" }
+  );
+  if (pipInstall.status !== 0) {
+    log("Failed to install Python dependencies. Check pip.");
+    process.exit(1);
+  }
+  log("Dependencies installed.");
+
+  // Step 4: Create ~/.nexo/
+  log("Setting up NEXO home...");
+  const dirs = [
+    NEXO_HOME,
+    path.join(NEXO_HOME, "plugins"),
+    path.join(NEXO_HOME, "scripts"),
+    path.join(NEXO_HOME, "logs"),
+    path.join(NEXO_HOME, "backups"),
+    path.join(NEXO_HOME, "coordination"),
+    path.join(NEXO_HOME, "brain"),
+  ];
+  dirs.forEach((d) => fs.mkdirSync(d, { recursive: true }));
+
+  // Write version file for auto-update tracking
+  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+  fs.writeFileSync(
+    path.join(NEXO_HOME, "version.json"),
+    JSON.stringify({
+      version: pkg.version,
+      installed_at: new Date().toISOString(),
+      files_updated: 0,
+    }, null, 2)
+  );
+
+  // Copy source files
+  const srcDir = path.join(__dirname, "..", "src");
+  const scriptsSrcDir = path.join(__dirname, "..", "src", "scripts");
+  const pluginsSrcDir = path.join(__dirname, "..", "src", "plugins");
+  const templateDir = path.join(__dirname, "..", "templates");
+
+  // Core files
+  const coreFiles = [
+    "server.py",
+    "db.py",
+    "plugin_loader.py",
+    "cognitive.py",
+    "tools_sessions.py",
+    "tools_coordination.py",
+    "tools_reminders.py",
+    "tools_reminders_crud.py",
+    "tools_learnings.py",
+    "tools_credentials.py",
+    "tools_task_history.py",
+    "tools_menu.py",
+  ];
+  coreFiles.forEach((f) => {
+    const src = path.join(srcDir, f);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(NEXO_HOME, f));
+    }
+  });
+
+  // Plugins
+  const pluginFiles = [
+    "__init__.py",
+    "guard.py",
+    "episodic_memory.py",
+    "cognitive_memory.py",
+    "entities.py",
+    "preferences.py",
+    "agents.py",
+    "backup.py",
+    "evolution.py",
+  ];
+  pluginFiles.forEach((f) => {
+    const src = path.join(pluginsSrcDir, f);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(NEXO_HOME, "plugins", f));
+    }
+  });
+
+  // Scripts
+  const scriptFiles = fs
+    .readdirSync(scriptsSrcDir || ".")
+    .filter((f) => f.endsWith(".py"));
+  scriptFiles.forEach((f) => {
+    const src = path.join(scriptsSrcDir, f);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(NEXO_HOME, "scripts", f));
+    }
+  });
+
+  // Generate personality
+  const personality = `# ${operatorName} — Personality
+
+I am ${operatorName}, a cognitive co-operator. Not an assistant — an operational partner.
+
+## Core traits
+- Direct: I say what I think, not what sounds nice
+- Action-oriented: I do things, I don't suggest things
+- Self-critical: I track my mistakes and learn from them
+- Proactive: If I can detect or fix something without being asked, I do it
+
+## What I never do
+- Ask the user to do something I can do myself
+- Say "I can't" without trying alternatives first
+- Give long explanations when a short answer suffices
+- Repeat mistakes I've already logged
+`;
+  fs.writeFileSync(path.join(NEXO_HOME, "brain", "personality.md"), personality);
+
+  // Generate user profile
+  const profile = `# User Profile
+
+Created: ${new Date().toISOString().split("T")[0]}
+Operator name: ${operatorName}
+
+## Observed preferences
+(${operatorName} will learn these over time)
+
+## Work patterns
+(${operatorName} will observe and record these)
+`;
+  fs.writeFileSync(path.join(NEXO_HOME, "brain", "user-profile.md"), profile);
+
+  // Step 5: Scan workspace
+  if (doScan) {
+    log("Scanning workspace...");
+    const cwd = process.cwd();
+    const findings = [];
+
+    // Git repos
+    const gitDirs = run(
+      `find "${cwd}" -maxdepth 3 -name ".git" -type d 2>/dev/null`
+    );
+    if (gitDirs) {
+      const repos = gitDirs.split("\n").filter(Boolean);
+      findings.push(`${repos.length} git repositories`);
+    }
+
+    // Package managers
+    if (fs.existsSync(path.join(cwd, "package.json")))
+      findings.push("Node.js project detected");
+    if (fs.existsSync(path.join(cwd, "requirements.txt")))
+      findings.push("Python project detected");
+    if (fs.existsSync(path.join(cwd, "Cargo.toml")))
+      findings.push("Rust project detected");
+    if (fs.existsSync(path.join(cwd, "go.mod")))
+      findings.push("Go project detected");
+
+    // Config files
+    if (fs.existsSync(path.join(cwd, ".env")))
+      findings.push(".env file found (will NOT read contents)");
+
+    if (findings.length > 0) {
+      log("Found:");
+      findings.forEach((f) => log(`  - ${f}`));
+    } else {
+      log("No projects detected in current directory.");
+    }
+
+    // Save scan results
+    fs.writeFileSync(
+      path.join(NEXO_HOME, "brain", "workspace-scan.json"),
+      JSON.stringify(
+        { scanned_at: new Date().toISOString(), cwd, findings },
+        null,
+        2
+      )
+    );
+  }
+
+  console.log("");
+
+  // Step 6: Configure Claude Code MCP
+  log("Configuring Claude Code MCP server...");
+  let settings = {};
+  if (fs.existsSync(CLAUDE_SETTINGS)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, "utf8"));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.mcpServers) settings.mcpServers = {};
+  settings.mcpServers.nexo = {
+    command: python,
+    args: [path.join(NEXO_HOME, "server.py")],
+    env: {
+      NEXO_HOME: NEXO_HOME,
+      NEXO_NAME: operatorName,
+    },
+  };
+
+  // Configure hooks for session capture (Sensory Register)
+  if (!settings.hooks) settings.hooks = {};
+
+  // Copy hook scripts to NEXO_HOME
+  const hooksSrcDir = path.join(__dirname, "..", "src", "hooks");
+  const hooksDestDir = path.join(NEXO_HOME, "hooks");
+  fs.mkdirSync(hooksDestDir, { recursive: true });
+  ["session-start.sh", "capture-session.sh", "session-stop.sh"].forEach((h) => {
+    const src = path.join(hooksSrcDir, h);
+    const dest = path.join(hooksDestDir, h);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, "755");
+    }
+  });
+
+  // SessionStart hook
+  if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
+  const startHook = {
+    type: "command",
+    command: `bash ${path.join(hooksDestDir, "session-start.sh")}`,
+  };
+  if (!settings.hooks.SessionStart.some((h) => h.command && h.command.includes("session-start.sh"))) {
+    settings.hooks.SessionStart.push(startHook);
+  }
+
+  // PostToolUse hook (captures tool usage to session_buffer)
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+  const captureHook = {
+    type: "command",
+    command: `bash ${path.join(hooksDestDir, "capture-session.sh")}`,
+  };
+  if (!settings.hooks.PostToolUse.some((h) => h.command && h.command.includes("capture-session.sh"))) {
+    settings.hooks.PostToolUse.push(captureHook);
+  }
+
+  // Stop hook (session end)
+  if (!settings.hooks.Stop) settings.hooks.Stop = [];
+  const stopHook = {
+    type: "command",
+    command: `bash ${path.join(hooksDestDir, "session-stop.sh")}`,
+  };
+  if (!settings.hooks.Stop.some((h) => h.command && h.command.includes("session-stop.sh"))) {
+    settings.hooks.Stop.push(stopHook);
+  }
+
+  const settingsDir = path.dirname(CLAUDE_SETTINGS);
+  fs.mkdirSync(settingsDir, { recursive: true });
+  fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+  log("MCP server + hooks configured in Claude Code settings.");
+
+  // Step 7: Install LaunchAgents
+  log("Setting up automated processes...");
+  fs.mkdirSync(LAUNCH_AGENTS, { recursive: true });
+
+  const agents = [
+    {
+      name: "cognitive-decay",
+      script: "nexo-cognitive-decay.py",
+      hour: 3,
+      minute: 0,
+    },
+    {
+      name: "postmortem",
+      script: "nexo-postmortem-consolidator.py",
+      hour: 23,
+      minute: 30,
+    },
+    {
+      name: "sleep",
+      script: "nexo-sleep.py",
+      hour: 4,
+      minute: 0,
+    },
+    {
+      name: "self-audit",
+      script: "nexo-daily-self-audit.py",
+      hour: 7,
+      minute: 0,
+    },
+    { name: "catchup", script: "nexo-catchup.py", runAtLoad: true },
+  ];
+
+  agents.forEach((agent) => {
+    const plistName = `com.nexo.${agent.name}.plist`;
+    const plistPath = path.join(LAUNCH_AGENTS, plistName);
+
+    let scheduleBlock = "";
+    if (agent.runAtLoad) {
+      scheduleBlock = `    <key>RunAtLoad</key>
+    <true/>`;
+    } else {
+      scheduleBlock = `    <key>StartCalendarInterval</key>
+    <dict>
+        <key>Hour</key>
+        <integer>${agent.hour}</integer>
+        <key>Minute</key>
+        <integer>${agent.minute}</integer>
+    </dict>
+    <key>RunAtLoad</key>
+    <false/>`;
+    }
+
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.nexo.${agent.name}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${python}</string>
+        <string>${path.join(NEXO_HOME, "scripts", agent.script)}</string>
+    </array>
+    ${scheduleBlock}
+    <key>StandardOutPath</key>
+    <string>${path.join(NEXO_HOME, "logs", `${agent.name}-stdout.log`)}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(NEXO_HOME, "logs", `${agent.name}-stderr.log`)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>HOME</key>
+        <string>${require("os").homedir()}</string>
+        <key>NEXO_HOME</key>
+        <string>${NEXO_HOME}</string>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+</dict>
+</plist>`;
+
+    fs.writeFileSync(plistPath, plist);
+    // Register the agent
+    try {
+      execSync(
+        `launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null; launchctl bootstrap gui/$(id -u) "${plistPath}"`,
+        { stdio: "pipe" }
+      );
+    } catch {
+      // May fail if not previously loaded, that's OK
+    }
+  });
+  log(`${agents.length} automated processes configured.`);
+
+  // Caffeinate: keep Mac awake for nocturnal processes
+  if (doCaffeinate) {
+    const caffHookSrc = path.join(__dirname, "..", "src", "hooks", "caffeinate-guard.sh");
+    const caffHookDest = path.join(NEXO_HOME, "hooks", "caffeinate-guard.sh");
+    if (fs.existsSync(caffHookSrc)) {
+      fs.copyFileSync(caffHookSrc, caffHookDest);
+      fs.chmodSync(caffHookDest, "755");
+    }
+
+    const caffPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.nexo.caffeinate</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>${caffHookDest}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${path.join(NEXO_HOME, "logs", "caffeinate-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(NEXO_HOME, "logs", "caffeinate-stderr.log")}</string>
+</dict>
+</plist>`;
+
+    const caffPlistPath = path.join(LAUNCH_AGENTS, "com.nexo.caffeinate.plist");
+    fs.writeFileSync(caffPlistPath, caffPlist);
+    try {
+      execSync(
+        `launchctl bootout gui/$(id -u) "${caffPlistPath}" 2>/dev/null; launchctl bootstrap gui/$(id -u) "${caffPlistPath}"`,
+        { stdio: "pipe" }
+      );
+    } catch {}
+    log("Caffeinate enabled — Mac will stay awake for cognitive processes.");
+  }
+
+  // Step 8: Create shell alias so user can just type the operator's name
+  log("Creating shell alias...");
+  const aliasName = operatorName.toLowerCase();
+  const aliasLine = `alias ${aliasName}='claude --dangerously-skip-permissions "."'`;
+  const aliasComment = `# ${operatorName} — start Claude Code with ${operatorName} speaking first`;
+
+  // Detect shell and add alias
+  const userShell = process.env.SHELL || "/bin/bash";
+  const rcFile = userShell.includes("zsh")
+    ? path.join(require("os").homedir(), ".zshrc")
+    : path.join(require("os").homedir(), ".bash_profile");
+
+  let rcContent = "";
+  if (fs.existsSync(rcFile)) {
+    rcContent = fs.readFileSync(rcFile, "utf8");
+  }
+
+  if (!rcContent.includes(`alias ${aliasName}=`)) {
+    fs.appendFileSync(rcFile, `\n${aliasComment}\n${aliasLine}\n`);
+    log(`Added '${aliasName}' alias to ${path.basename(rcFile)}`);
+    log(`After setup, open a new terminal and type: ${aliasName}`);
+  } else {
+    log(`Alias '${aliasName}' already exists in ${path.basename(rcFile)}`);
+  }
+  console.log("");
+
+  // Step 9: Generate CLAUDE.md template
+  log("Generating operator instructions...");
+  const templateSrc = path.join(templateDir, "CLAUDE.md.template");
+  let claudeMd = "";
+  if (fs.existsSync(templateSrc)) {
+    claudeMd = fs
+      .readFileSync(templateSrc, "utf8")
+      .replace(/\{\{NAME\}\}/g, operatorName)
+      .replace(/\{\{NEXO_HOME\}\}/g, NEXO_HOME);
+  } else {
+    claudeMd = `# ${operatorName} — Cognitive Co-Operator
+
+Instructions for ${operatorName} are generated during setup.
+See ~/.nexo/ for configuration.
+`;
+  }
+
+  // Write to user's global CLAUDE.md if it doesn't exist
+  const userClaudeMd = path.join(require("os").homedir(), ".claude", "CLAUDE.md");
+  if (!fs.existsSync(userClaudeMd)) {
+    fs.writeFileSync(userClaudeMd, claudeMd);
+    log("Created ~/.claude/CLAUDE.md with operator instructions.");
+  } else {
+    // Save as reference
+    fs.writeFileSync(path.join(NEXO_HOME, "CLAUDE.md.generated"), claudeMd);
+    log(
+      "~/.claude/CLAUDE.md already exists. Generated template saved to ~/.nexo/CLAUDE.md.generated"
+    );
+  }
+
+  console.log("");
+  console.log(
+    "  ╔══════════════════════════════════════════════════════════╗"
+  );
+  console.log(
+    `  ║  ${operatorName} is ready. Type '${aliasName}' to start.${" ".repeat(Math.max(0, 30 - operatorName.length - aliasName.length))}║`
+  );
+  console.log(
+    "  ╚══════════════════════════════════════════════════════════╝"
+  );
+  console.log("");
+
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error("Setup failed:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, trust scoring, and metacognitive error prevention.",
   "bin": {
@@ -13,7 +13,9 @@
     "memory",
     "ai-assistant",
     "vector-search",
-    "atkinson-shiffrin"
+    "atkinson-shiffrin",
+    "openclaw",
+    "openclaw-plugin"
   ],
   "author": "Francisco Garcia <hello@wazion.com>",
   "license": "MIT",