eon-memory 1.0.0

package/bin/eon.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (command === "init") {
+  require("../src/init.js");
+} else if (command === "status") {
+  require("../src/status.js");
+} else if (command === "test") {
+  require("../src/test-connection.js");
+} else if (command === "--help" || command === "-h" || !command) {
+  console.log(`
+  eon-memory - Persistent AI Memory System
+
+  Usage:
+    npx eon-memory init          Set up EON Memory for this project
+    npx eon-memory status        Check connection status
+    npx eon-memory test          Test MCP connectivity
+
+  Setup:
+    1. Register at https://app.ai-developer.ch
+    2. Create an API key in Settings
+    3. Run: npx eon-memory init
+
+  Docs: https://app.ai-developer.ch/capabilities
+`);
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.log("Run 'npx eon-memory --help' for usage.");
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "eon-memory",
+  "version": "1.0.0",
+  "description": "EON Memory - Persistent AI memory system. Connect Claude Code, Cursor, or VS Code to your memory.",
+  "bin": {
+    "eon-memory": "./bin/eon.js"
+  },
+  "keywords": ["mcp", "memory", "ai", "claude", "cursor", "context"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vasic-solutions/eon-memory"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ]
+}

package/src/init.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+/**
+ * eon-memory init
+ *
+ * Sets up EON Memory for the current project:
+ * 1. Prompts for API key
+ * 2. Validates against the server
+ * 3. Adds MCP config to Claude Code settings
+ * 4. Generates CLAUDE.md in the project
+ */
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const https = require("https");
+const os = require("os");
+
+const MCP_URL = "https://mcp.ai-developer.ch/mcp";
+const API_BASE = "https://app.ai-developer.ch";
+const INIT_ENDPOINT = "https://app.ai-developer.ch/api/proxy/cli/init";
+const CLAUDE_MD_ENDPOINT = "https://app.ai-developer.ch/api/proxy/cli/claude-md";
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function httpPost(url, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const data = JSON.stringify(body);
+    const req = https.request(
+      {
+        hostname: parsed.hostname,
+        port: 443,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+          ...headers,
+        },
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          try {
+            resolve({ status: res.statusCode, data: JSON.parse(body) });
+          } catch {
+            resolve({ status: res.statusCode, data: body });
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+function httpGet(url, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const req = https.request(
+      {
+        hostname: parsed.hostname,
+        port: 443,
+        path: parsed.pathname,
+        method: "GET",
+        headers,
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          try {
+            resolve({ status: res.statusCode, data: JSON.parse(body) });
+          } catch {
+            resolve({ status: res.statusCode, data: body });
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function addToClaudeConfig(apiKey) {
+  // Try Claude Code's config locations
+  const configPaths = [
+    // Project-level (preferred)
+    path.join(process.cwd(), ".mcp.json"),
+  ];
+
+  const mcpEntry = {
+    "eon-memory": {
+      type: "streamable-http",
+      url: MCP_URL,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    },
+  };
+
+  // Write to .mcp.json in project root (Claude Code auto-discovers this)
+  const mcpConfigPath = configPaths[0];
+  let existing = {};
+  if (fs.existsSync(mcpConfigPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
+    } catch {
+      existing = {};
+    }
+  }
+
+  if (!existing.mcpServers) existing.mcpServers = {};
+  existing.mcpServers["eon-memory"] = mcpEntry["eon-memory"];
+
+  fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2) + "\n");
+  return mcpConfigPath;
+}
+
+function writeClaudeMd(content) {
+  const claudeMdPath = path.join(process.cwd(), "CLAUDE.md");
+
+  // Don't overwrite existing CLAUDE.md, append instead
+  if (fs.existsSync(claudeMdPath)) {
+    const existing = fs.readFileSync(claudeMdPath, "utf-8");
+    if (existing.includes("EON Memory")) {
+      console.log("  CLAUDE.md already contains EON Memory config - skipping.");
+      return claudeMdPath;
+    }
+    fs.appendFileSync(claudeMdPath, "\n\n" + content);
+    console.log("  Appended EON Memory section to existing CLAUDE.md");
+  } else {
+    fs.writeFileSync(claudeMdPath, content);
+    console.log("  Created CLAUDE.md with EON Memory instructions");
+  }
+  return claudeMdPath;
+}
+
+async function main() {
+  console.log("\n  EON Memory - Setup\n");
+  console.log("  This will configure EON Memory for your project.\n");
+
+  // Step 1: Get API key
+  const apiKey = await ask("  Enter your API key (from app.ai-developer.ch/settings): ");
+
+  if (!apiKey) {
+    console.error("\n  Error: API key is required.");
+    console.log("  Get one at: https://app.ai-developer.ch/settings\n");
+    process.exit(1);
+  }
+
+  // Step 2: Validate API key
+  console.log("\n  Validating API key...");
+  try {
+    const res = await httpPost(INIT_ENDPOINT, { api_key: apiKey });
+
+    if (res.status !== 200) {
+      console.error("  Error: Invalid API key.");
+      console.log("  Check your key at: https://app.ai-developer.ch/settings\n");
+      process.exit(1);
+    }
+
+    const info = res.data;
+    console.log(`  Connected as: ${info.name || info.tenant_id} (${info.tier} plan)`);
+    console.log(`  Projects: ${(info.projects || []).length}`);
+    console.log(`  Tools: ${info.tools_count}`);
+  } catch (err) {
+    console.error(`  Error: Could not reach server - ${err.message}`);
+    process.exit(1);
+  }
+
+  // Step 3: Write MCP config
+  console.log("\n  Configuring MCP...");
+  const configPath = addToClaudeConfig(apiKey);
+  console.log(`  Wrote: ${path.relative(process.cwd(), configPath)}`);
+
+  // Step 4: Fetch and write CLAUDE.md
+  console.log("\n  Generating CLAUDE.md...");
+  try {
+    const res = await httpGet(CLAUDE_MD_ENDPOINT, { "X-API-Key": apiKey });
+    if (res.status === 200 && res.data.content) {
+      const claudeMdPath = writeClaudeMd(res.data.content);
+      console.log(`  Wrote: ${path.relative(process.cwd(), claudeMdPath)}`);
+    } else {
+      console.log("  Warning: Could not fetch CLAUDE.md template (non-critical).");
+    }
+  } catch {
+    console.log("  Warning: Could not fetch CLAUDE.md template (non-critical).");
+  }
+
+  // Done
+  console.log("\n  Setup complete!\n");
+  console.log("  Next steps:");
+  console.log("  1. Open this project in Claude Code or Cursor");
+  console.log("  2. The EON Memory tools will be available automatically");
+  console.log("  3. Try: \"Search my memories for...\" or \"Create a memory about...\"\n");
+  console.log(`  Dashboard: ${API_BASE}`);
+  console.log(`  Run 'npx eon-memory status' to check connection.\n`);
+}
+
+main().catch((err) => {
+  console.error(`\n  Error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/status.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+/**
+ * eon-memory status
+ *
+ * Checks if EON Memory is configured and connected.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+
+function checkMcpConfig() {
+  const mcpPath = path.join(process.cwd(), ".mcp.json");
+  if (!fs.existsSync(mcpPath)) return null;
+
+  try {
+    const config = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+    return config.mcpServers?.["eon-memory"] || null;
+  } catch {
+    return null;
+  }
+}
+
+function checkHealth() {
+  return new Promise((resolve) => {
+    const req = https.get("https://mcp.ai-developer.ch/health", (res) => {
+      let body = "";
+      res.on("data", (chunk) => (body += chunk));
+      res.on("end", () => {
+        try {
+          resolve({ ok: res.statusCode === 200, data: JSON.parse(body) });
+        } catch {
+          resolve({ ok: false });
+        }
+      });
+    });
+    req.on("error", () => resolve({ ok: false }));
+    req.setTimeout(5000, () => { req.destroy(); resolve({ ok: false }); });
+  });
+}
+
+async function main() {
+  console.log("\n  EON Memory - Status\n");
+
+  // Check config
+  const config = checkMcpConfig();
+  if (config) {
+    console.log("  MCP Config:    found (.mcp.json)");
+    console.log(`  Server URL:    ${config.url || "not set"}`);
+    console.log(`  Auth:          ${config.headers?.Authorization ? "configured" : "missing"}`);
+  } else {
+    console.log("  MCP Config:    not found");
+    console.log("  Run 'npx eon-memory init' to set up.\n");
+    return;
+  }
+
+  // Check CLAUDE.md
+  const claudeMd = path.join(process.cwd(), "CLAUDE.md");
+  console.log(`  CLAUDE.md:     ${fs.existsSync(claudeMd) ? "found" : "not found"}`);
+
+  // Check server health
+  console.log("\n  Checking server...");
+  const health = await checkHealth();
+  if (health.ok) {
+    console.log(`  Server:        online`);
+    console.log(`  Tools:         ${health.data?.tools || "?"}`);
+    console.log(`  Version:       ${health.data?.version || "?"}`);
+  } else {
+    console.log("  Server:        unreachable");
+  }
+
+  console.log("");
+}
+
+main();

package/src/test-connection.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+/**
+ * eon-memory test
+ *
+ * Tests the MCP connection with the configured API key.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+
+function getApiKey() {
+  // Try .mcp.json
+  const mcpPath = path.join(process.cwd(), ".mcp.json");
+  if (fs.existsSync(mcpPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+      const auth = config.mcpServers?.["eon-memory"]?.headers?.Authorization;
+      if (auth) return auth.replace("Bearer ", "");
+    } catch {}
+  }
+
+  // Try env
+  if (process.env.EON_API_KEY) return process.env.EON_API_KEY;
+
+  return null;
+}
+
+function httpPost(url, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const data = JSON.stringify(body);
+    const req = https.request(
+      {
+        hostname: parsed.hostname,
+        port: 443,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+          ...headers,
+        },
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          try {
+            resolve({ status: res.statusCode, data: JSON.parse(body) });
+          } catch {
+            resolve({ status: res.statusCode, data: body });
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+async function main() {
+  console.log("\n  EON Memory - Connection Test\n");
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.log("  No API key found.");
+    console.log("  Run 'npx eon-memory init' first.\n");
+    process.exit(1);
+  }
+
+  console.log("  Testing connection...");
+  const start = Date.now();
+
+  try {
+    const res = await httpPost("https://app.ai-developer.ch/api/proxy/cli/test", {
+      api_key: apiKey,
+    });
+
+    const latency = Date.now() - start;
+
+    if (res.status === 200) {
+      const d = res.data;
+      console.log(`  Status:        ${d.status}`);
+      console.log(`  Tenant:        ${d.tenant_id}`);
+      console.log(`  Plan:          ${d.tier}`);
+      console.log(`  Memories:      ${d.memory_count}`);
+      console.log(`  Tools:         ${d.tools_available}`);
+      console.log(`  Latency:       ${latency}ms`);
+      console.log("\n  Connection successful!\n");
+    } else {
+      console.log(`  Error: ${res.data?.detail || "Authentication failed"}`);
+      console.log("  Check your API key in .mcp.json\n");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.log(`  Error: ${err.message}`);
+    console.log("  Could not reach server.\n");
+    process.exit(1);
+  }
+}
+
+main();