@steinx/memory-mcp-1file 0.9.0

package/README.md

@@ -0,0 +1,64 @@
+# @steinx/memory-mcp-1file
+
+MCP memory server with semantic search, code indexing, and knowledge graph for AI agents.
+
+## Quick Start
+
+```bash
+# Run directly (downloads binary automatically)
+npx @steinx/memory-mcp-1file
+
+# Or with bun
+bunx @steinx/memory-mcp-1file
+```
+
+If you republish this wrapper from a fork, the release workflow automatically derives the published npm scope and repository metadata from the current GitHub repository. For local testing and non-release installs, keep the checked-in `repository` field in `npm/package.json` accurate so the postinstall hook downloads release assets from your repository, or override it at install time with `MEMORY_MCP_RELEASE_REPO=owner/repo`.
+
+## What is this?
+
+`memory-mcp` is a [Model Context Protocol](https://modelcontextprotocol.io/) server that provides AI agents with:
+
+- **Semantic memory** — store and search memories with embeddings
+- **Code indexing** — parse and index codebases with tree-sitter
+- **Knowledge graph** — entity extraction and relationship tracking
+- **Temporal awareness** — time-based memory queries
+
+## Configuration
+
+Use with Claude Code, Cursor, or any MCP-compatible client:
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "npx",
+      "args": ["-y", "@steinx/memory-mcp-1file"]
+    }
+  }
+}
+```
+
+## CLI Options
+
+```bash
+memory-mcp --help          # Show all options
+memory-mcp --data-dir /data # Custom database path
+```
+
+## Supported Platforms
+
+| Platform | Architecture |
+|---|---|
+| Linux | x86_64 (musl), ARM64 (musl) |
+| macOS | x86_64, ARM64 (Apple Silicon) |
+| Windows | x86_64 |
+
+## Links
+
+- [GitHub Repository](https://github.com/SteinX/memory-mcp-1file)
+- [Releases](https://github.com/SteinX/memory-mcp-1file/releases)
+- [Architecture](https://github.com/SteinX/memory-mcp-1file/blob/master/ARCHITECTURE.md)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@steinx/memory-mcp-1file",
+    "version": "0.9.0",
+    "description": "MCP memory server with semantic search, code indexing, and knowledge graph for AI agents",
+    "bin": {
+        "memory-mcp": "run.js"
+    },
+    "scripts": {
+        "postinstall": "node postinstall.js"
+    },
+    "keywords": [
+        "mcp",
+        "memory",
+        "ai",
+        "semantic-search",
+        "knowledge-graph",
+        "code-indexing",
+        "model-context-protocol"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/SteinX/memory-mcp-1file.git"
+    },
+    "homepage": "https://github.com/SteinX/memory-mcp-1file#readme",
+    "bugs": {
+        "url": "https://github.com/SteinX/memory-mcp-1file/issues"
+    },
+    "license": "MIT",
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org",
+        "access": "public"
+    },
+    "files": [
+        "run.js",
+        "postinstall.js",
+        "README.md"
+    ]
+}

package/postinstall.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall.js — downloads the pre-compiled memory-mcp binary
+ * from GitHub Releases for the current platform.
+ *
+ * Zero external dependencies — uses only Node.js built-ins.
+ */
+
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const os = require("os");
+const zlib = require("zlib");
+
+const BINARY_NAME = "memory-mcp";
+
+// Map Node.js platform/arch to Rust target triples
+const PLATFORM_MAP = {
+    "linux-x64": "x86_64-unknown-linux-musl",
+    "linux-arm64": "aarch64-unknown-linux-musl",
+    "darwin-x64": "x86_64-apple-darwin",
+    "darwin-arm64": "aarch64-apple-darwin",
+    "win32-x64": "x86_64-pc-windows-msvc",
+};
+
+function getPlatformKey() {
+    return `${process.platform}-${process.arch}`;
+}
+
+function getTarget() {
+    const key = getPlatformKey();
+    const target = PLATFORM_MAP[key];
+    if (!target) {
+        console.error(
+            `Unsupported platform: ${key}\n` +
+            `Supported platforms: ${Object.keys(PLATFORM_MAP).join(", ")}`
+        );
+        process.exit(1);
+    }
+    return target;
+}
+
+function getVersion() {
+    const pkg = JSON.parse(
+        fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
+    );
+    return pkg.version;
+}
+
+function getRepo() {
+    const envRepo = process.env.MEMORY_MCP_RELEASE_REPO?.trim();
+    if (envRepo) {
+        return envRepo.replace(/^https:\/\/github\.com\//, "").replace(/\.git$/, "");
+    }
+
+    const pkg = JSON.parse(
+        fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
+    );
+    const repository = pkg.repository;
+    const repositoryUrl = typeof repository === "string" ? repository : repository?.url;
+
+    if (typeof repositoryUrl === "string") {
+        const normalized = repositoryUrl
+            .replace(/^git\+/, "")
+            .replace(/^https:\/\/github\.com\//, "")
+            .replace(/^git@github\.com:/, "")
+            .replace(/\.git$/, "");
+
+        if (normalized.includes("/")) {
+            return normalized;
+        }
+    }
+
+    return "SteinX/memory-mcp-1file";
+}
+
+function getDownloadUrl(repo, version, target) {
+    const ext = target.includes("windows") ? ".zip" : ".tar.gz";
+    return `https://github.com/${repo}/releases/download/v${version}/${BINARY_NAME}-${version}-${target}${ext}`;
+}
+
+/**
+ * Follow redirects (GitHub releases use 302 → S3).
+ */
+function download(url) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith("https") ? https : http;
+        client
+            .get(url, { headers: { "User-Agent": "memory-mcp-npm" } }, (res) => {
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    return download(res.headers.location).then(resolve, reject);
+                }
+                if (res.statusCode !== 200) {
+                    return reject(
+                        new Error(`Download failed: HTTP ${res.statusCode} for ${url}`)
+                    );
+                }
+                const chunks = [];
+                res.on("data", (chunk) => chunks.push(chunk));
+                res.on("end", () => resolve(Buffer.concat(chunks)));
+                res.on("error", reject);
+            })
+            .on("error", reject);
+    });
+}
+
+/**
+ * Extract .tar.gz using Node.js built-in zlib + tar command.
+ */
+async function extractTarGz(buffer, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    const tmpFile = path.join(os.tmpdir(), `memory-mcp-${Date.now()}.tar.gz`);
+    fs.writeFileSync(tmpFile, buffer);
+    try {
+        execSync(`tar -xzf "${tmpFile}" -C "${destDir}"`, { stdio: "pipe" });
+    } finally {
+        fs.unlinkSync(tmpFile);
+    }
+}
+
+/**
+ * Extract .zip using unzip command (available on Windows via PowerShell).
+ */
+async function extractZip(buffer, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    const tmpFile = path.join(os.tmpdir(), `memory-mcp-${Date.now()}.zip`);
+    fs.writeFileSync(tmpFile, buffer);
+    try {
+        if (process.platform === "win32") {
+            execSync(
+                `powershell -Command "Expand-Archive -Path '${tmpFile}' -DestinationPath '${destDir}' -Force"`,
+                { stdio: "pipe" }
+            );
+        } else {
+            execSync(`unzip -o "${tmpFile}" -d "${destDir}"`, { stdio: "pipe" });
+        }
+    } finally {
+        fs.unlinkSync(tmpFile);
+    }
+}
+
+async function main() {
+    const repo = getRepo();
+    const target = getTarget();
+    const version = getVersion();
+    const url = getDownloadUrl(repo, version, target);
+    const binDir = path.join(__dirname, "bin");
+    const isWindows = target.includes("windows");
+    const binaryPath = path.join(
+        binDir,
+        isWindows ? `${BINARY_NAME}.exe` : BINARY_NAME
+    );
+
+    // Skip if binary already exists
+    if (fs.existsSync(binaryPath)) {
+        console.log(`memory-mcp binary already exists at ${binaryPath}`);
+        return;
+    }
+
+    console.log(`Downloading memory-mcp v${version} for ${target} from ${repo}...`);
+    console.log(`  URL: ${url}`);
+
+    try {
+        const buffer = await download(url);
+
+        if (isWindows) {
+            await extractZip(buffer, binDir);
+        } else {
+            await extractTarGz(buffer, binDir);
+        }
+
+        // Make binary executable on Unix
+        if (!isWindows) {
+            fs.chmodSync(binaryPath, 0o755);
+        }
+
+        console.log(`✅ memory-mcp installed successfully at ${binaryPath}`);
+    } catch (err) {
+        console.error(`\n❌ Failed to install memory-mcp binary:`);
+        console.error(`   ${err.message}`);
+        console.error(
+            `\nYou can manually download the binary from:`
+        );
+        console.error(
+            `   https://github.com/${repo}/releases/tag/v${version}`
+        );
+        process.exit(1);
+    }
+}
+
+main();

package/run.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+/**
+ * run.js — entry point for `npx memory-mcp` / `bunx memory-mcp`.
+ * Finds and executes the pre-compiled binary, proxying stdio and args.
+ */
+
+const { spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const isWindows = process.platform === "win32";
+const binaryName = isWindows ? "memory-mcp.exe" : "memory-mcp";
+const binaryPath = path.join(__dirname, "bin", binaryName);
+
+if (!fs.existsSync(binaryPath)) {
+    console.error(
+        `❌ memory-mcp binary not found at ${binaryPath}\n` +
+        `   Run "node postinstall.js" to download it, or reinstall the package.`
+    );
+    process.exit(1);
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env,
+});
+
+child.on("error", (err) => {
+    console.error(`Failed to start memory-mcp: ${err.message}`);
+    process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+    if (signal) {
+        process.kill(process.pid, signal);
+    } else {
+        process.exit(code ?? 1);
+    }
+});