mycelicmemory 1.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MycelicMemory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,301 @@
+# MyclicMemory
+
+<p align="center">
+  <strong>AI-powered persistent memory system for Claude and other AI agents</strong>
+</p>
+
+<p align="center">
+  <a href="#installation">Installation</a> •
+  <a href="#connect-to-claude">Connect to Claude</a> •
+  <a href="#features">Features</a> •
+  <a href="#optional-ai-features">AI Features</a>
+</p>
+
+---
+
+MyclicMemory gives Claude persistent memory across conversations. Store knowledge, search semantically, and get AI-powered insights from your memories.
+
+**Free and open source** - no license keys, no subscriptions.
+
+---
+
+## Installation
+
+### Prerequisites
+
+**Required:**
+- **Node.js 18+** (includes npm)
+
+**Optional (for enhanced AI features):**
+- **Ollama** - For semantic search and AI analysis
+
+### Install via npm
+
+```bash
+npm install -g mycelicmemory
+```
+
+**Important:** After installation, run `mycelicmemory` once to download the platform-specific binary:
+
+```bash
+mycelicmemory --version
+```
+
+The first run automatically downloads and caches the binary for your system (macOS, Linux, or Windows).
+
+### Alternative: Install from GitHub
+
+```bash
+npm install -g github:MycelicMemory/mycelicmemory
+```
+
+### Verify Installation
+
+```bash
+mycelicmemory --version    # Should show version
+mycelicmemory doctor       # Check system dependencies
+```
+
+---
+
+## Connect to Claude
+
+### Claude Code (CLI)
+
+Edit `~/.claude/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "mycelicmemory": {
+      "command": "mycelicmemory",
+      "args": ["--mcp"]
+    }
+  }
+}
+```
+
+Restart Claude Code:
+
+```bash
+claude
+```
+
+### Claude Desktop
+
+Edit your config file:
+
+| Platform | Location |
+|----------|----------|
+| macOS | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Windows | `%APPDATA%\Claude\claude_desktop_config.json` |
+| Linux | `~/.config/Claude/claude_desktop_config.json` |
+
+Add:
+
+```json
+{
+  "mcpServers": {
+    "mycelicmemory": {
+      "command": "mycelicmemory",
+      "args": ["--mcp"]
+    }
+  }
+}
+```
+
+Restart Claude Desktop.
+
+### Test It Works
+
+Ask Claude:
+- "Remember that mycelicmemory is now working"
+- "What memories do I have?"
+
+---
+
+## Features
+
+### Memory Operations
+
+| Tool | Description |
+|------|-------------|
+| `store_memory` | Save memories with importance (1-10), tags, and domain |
+| `search` | Semantic, keyword, tag, or hybrid search |
+| `get_memory_by_id` | Retrieve specific memory by UUID |
+| `update_memory` | Modify content, importance, or tags |
+| `delete_memory` | Remove a memory permanently |
+
+### AI Analysis (requires Ollama)
+
+| Tool | Description |
+|------|-------------|
+| `analysis(question)` | Ask natural language questions about your memories |
+| `analysis(summarize)` | Generate summaries across timeframes |
+| `analysis(analyze)` | Detect patterns and themes |
+
+### Knowledge Organization
+
+| Tool | Description |
+|------|-------------|
+| `relationships` | Create/discover connections between memories |
+| `categories` | Organize memories hierarchically |
+| `domains` | Group by knowledge domain |
+| `sessions` | Track memories by session |
+
+---
+
+## Optional: AI Features
+
+MyclicMemory works without AI services, but semantic search and AI-powered analysis require **Ollama**.
+
+### Install Ollama
+
+**macOS:**
+```bash
+brew install ollama
+ollama serve
+```
+
+**Linux:**
+```bash
+curl -fsSL https://ollama.ai/install.sh | sh
+ollama serve
+```
+
+**Windows:**
+Download from [ollama.ai](https://ollama.ai/download)
+
+### Download Models
+
+```bash
+ollama pull nomic-embed-text   # For semantic search
+ollama pull qwen2.5:3b         # For AI analysis
+```
+
+### Verify
+
+```bash
+mycelicmemory doctor
+# Should show: Ollama: Available
+```
+
+---
+
+## CLI Usage
+
+MyclicMemory also works as a standalone CLI:
+
+```bash
+# Store memories
+mycelicmemory remember "Go interfaces are satisfied implicitly"
+mycelicmemory remember "Important!" --importance 9 --tags learning,go
+
+# Search
+mycelicmemory search "concurrency patterns"
+
+# AI analysis (requires Ollama)
+mycelicmemory analyze "What have I learned about testing?"
+
+# Service management
+mycelicmemory start    # Start REST API daemon
+mycelicmemory stop     # Stop daemon
+mycelicmemory doctor   # Health check
+```
+
+---
+
+## Configuration
+
+Config file: `~/.mycelicmemory/config.yaml`
+
+```yaml
+database:
+  path: ~/.mycelicmemory/memories.db
+
+rest_api:
+  port: 3099
+  host: localhost
+
+ollama:
+  enabled: true
+  base_url: http://localhost:11434
+  embedding_model: nomic-embed-text
+  chat_model: qwen2.5:3b
+```
+
+---
+
+## Build from Source
+
+If you prefer to build from source (requires Go 1.23+ and a C compiler):
+
+```bash
+git clone https://github.com/MycelicMemory/mycelicmemory.git
+cd mycelicmemory
+make deps && make build && make install
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup.
+
+---
+
+## Troubleshooting
+
+### "command not found: mycelicmemory"
+
+Ensure npm global bin is in your PATH:
+
+```bash
+npm bin -g
+# Add this directory to your PATH
+```
+
+### MCP Not Available in Claude
+
+```bash
+# Verify installation
+which mycelicmemory
+mycelicmemory --version
+
+# Test MCP mode
+echo '{"jsonrpc":"2.0","id":1,"method":"initialize"}' | mycelicmemory --mcp
+
+# Validate config
+cat ~/.claude/mcp.json | python3 -m json.tool
+```
+
+### macOS Security Warning
+
+If macOS blocks the binary:
+1. Go to System Preferences > Security & Privacy > General
+2. Click "Allow Anyway" next to the mycelicmemory message
+
+### Full Diagnostics
+
+```bash
+mycelicmemory doctor
+```
+
+---
+
+## Documentation
+
+- [Quick Start Guide](docs/QUICKSTART.md)
+- [Use Cases](docs/USE_CASES.md) - 15 detailed examples
+- [Hooks Setup](docs/HOOKS.md) - Automatic memory capture
+- [Contributing](CONTRIBUTING.md)
+
+---
+
+## License
+
+MIT License - Free and open source.
+
+---
+
+## Links
+
+- **Repository**: [github.com/MycelicMemory/mycelicmemory](https://github.com/MycelicMemory/mycelicmemory)
+- **Issues**: [GitHub Issues](https://github.com/MycelicMemory/mycelicmemory/issues)
+- **npm**: [npmjs.com/package/mycelicmemory](https://npmjs.com/package/mycelicmemory)

package/bin/mycelicmemory

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+
+/**
+ * MyclicMemory CLI - AI-powered persistent memory system
+ * Self-contained entry point that downloads the binary on first run
+ */
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+const VERSION = '1.2.2';
+const GITHUB_OWNER = 'MycelicMemory';
+const GITHUB_REPO = 'mycelicmemory';
+
+/**
+ * Get the binary filename for the current platform
+ */
+function getBinaryName() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const names = {
+    'darwin-arm64': 'mycelicmemory-macos-arm64',
+    'darwin-x64': 'mycelicmemory-macos-x64',
+    'linux-arm64': 'mycelicmemory-linux-arm64',
+    'linux-x64': 'mycelicmemory-linux-x64',
+    'win32-x64': 'mycelicmemory-windows-x64.exe',
+    'win32-arm64': 'mycelicmemory-windows-x64.exe',
+  };
+
+  const key = `${platform}-${arch}`;
+  const name = names[key];
+
+  if (!name) {
+    console.error(`Unsupported platform: ${key}`);
+    console.error('Supported: darwin-arm64, darwin-x64, linux-arm64, linux-x64, win32-x64');
+    process.exit(1);
+  }
+
+  return name;
+}
+
+/**
+ * Get the bin directory (same as this script's directory)
+ */
+function getBinDir() {
+  return __dirname;
+}
+
+/**
+ * Get full path to the binary
+ */
+function getBinaryPath() {
+  return path.join(getBinDir(), getBinaryName());
+}
+
+/**
+ * Download a file with redirect support
+ */
+function downloadFile(url, dest, maxRedirects = 10) {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      reject(new Error('Too many redirects'));
+      return;
+    }
+
+    const parsedUrl = new URL(url);
+    const protocol = parsedUrl.protocol === 'https:' ? https : http;
+
+    const request = protocol.get(url, {
+      headers: {
+        'User-Agent': `mycelicmemory/${VERSION}`,
+        'Accept': 'application/octet-stream'
+      }
+    }, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        const redirectUrl = new URL(response.headers.location, url).toString();
+        downloadFile(redirectUrl, dest, maxRedirects - 1).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(dest);
+      let downloadedBytes = 0;
+      const totalBytes = parseInt(response.headers['content-length'], 10) || 0;
+
+      response.on('data', (chunk) => {
+        downloadedBytes += chunk.length;
+        if (totalBytes > 0 && process.stdout.isTTY) {
+          const percent = Math.round((downloadedBytes / totalBytes) * 100);
+          process.stdout.write(`\rDownloading... ${percent}%`);
+        }
+      });
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        if (process.stdout.isTTY) process.stdout.write('\n');
+        resolve();
+      });
+
+      file.on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+    });
+
+    request.on('error', reject);
+    request.setTimeout(120000, () => {
+      request.destroy();
+      reject(new Error('Download timeout'));
+    });
+  });
+}
+
+/**
+ * Verify the downloaded binary
+ */
+function verifyBinary(binaryPath) {
+  const stats = fs.statSync(binaryPath);
+  if (stats.size < 1000000) {
+    throw new Error('Binary too small, download may have failed');
+  }
+
+  if (os.platform() !== 'win32') {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
+  try {
+    execSync(`"${binaryPath}" --version`, { encoding: 'utf8', timeout: 10000, stdio: 'pipe' });
+  } catch (err) {
+    if (os.platform() === 'darwin') {
+      console.log('Note: On macOS, allow the binary in System Preferences > Security');
+    }
+  }
+}
+
+/**
+ * Download binary if not present
+ */
+async function ensureBinary() {
+  const binaryPath = getBinaryPath();
+
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+
+  console.log(`Downloading mycelicmemory for ${os.platform()}-${os.arch()}...`);
+
+  const binaryName = getBinaryName();
+  const urls = [
+    `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases/download/v${VERSION}/${binaryName}`,
+    `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases/latest/download/${binaryName}`
+  ];
+
+  for (const url of urls) {
+    try {
+      await downloadFile(url, binaryPath);
+      verifyBinary(binaryPath);
+      console.log('Download complete!');
+      return binaryPath;
+    } catch (err) {
+      if (fs.existsSync(binaryPath)) fs.unlinkSync(binaryPath);
+    }
+  }
+
+  console.error('Failed to download binary.');
+  console.error(`Download manually from: https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases`);
+  process.exit(1);
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  try {
+    const binaryPath = await ensureBinary();
+
+    const child = spawn(binaryPath, process.argv.slice(2), {
+      stdio: 'inherit',
+      env: process.env
+    });
+
+    child.on('exit', (code) => process.exit(code || 0));
+    child.on('error', (err) => {
+      console.error(`Failed to start: ${err.message}`);
+      process.exit(1);
+    });
+
+    ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach((sig) => {
+      process.on(sig, () => child.pid && child.kill(sig));
+    });
+
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "mycelicmemory",
+  "version": "1.2.2",
+  "description": "AI-powered persistent memory system for Claude and other AI agents",
+  "keywords": [
+    "mcp",
+    "ai",
+    "memory",
+    "claude",
+    "anthropic",
+    "llm",
+    "vector-search",
+    "semantic-search",
+    "knowledge-base",
+    "ollama"
+  ],
+  "author": "Mycelic Memory",
+  "license": "MIT",
+  "homepage": "https://github.com/MycelicMemory/mycelicmemory",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MycelicMemory/mycelicmemory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MycelicMemory/mycelicmemory/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "bin": {
+    "mycelicmemory": "bin/mycelicmemory"
+  },
+  "files": [
+    "bin/mycelicmemory",
+    "README.md",
+    "LICENSE"
+  ]
+}