persyst-mcp 2.2.4 → 2.2.6

package/README.md

@@ -1,8 +1,23 @@
 # Persyst
 
-**Local-first MCP memory server for coding agents.**
+**Local-first, compliance-grade MCP memory layer for regulated enterprise coding teams using AI assistants.**
 
-Persyst gives AI coding agents (Claude Code, Cursor, VS Code, Aider, Windsurf, Antigravity) persistent memory across sessions. It stores memories in a local SQLite database with hybrid keyword + semantic search — no cloud, no API keys, works offline.
+Persyst gives AI coding agents (Claude Code, Cursor, VS Code, Aider, Continue.dev, Antigravity) persistent memory across sessions. It stores memories in a local SQLite database with hybrid keyword + semantic search — operating 100% offline with zero cloud egress.
+
+## Compliance-Grade Security Features
+
+Persyst is built from the ground up for highly regulated enterprise environments (finance, healthcare, defense) subject to **SOC 2**, **HIPAA**, and the **EU AI Act**:
+
+* **100% Data Residency (Zero-Egress)**: All vector calculations, full-text searches, and model inferences run locally on the developer's workstation. No database records or context data ever leave the local machine. Bypasses Business Associate Agreement (BAA) complexity for HIPAA.
+* **Cryptographic Chain of Custody**: Every context retrieval generates an Ed25519 cryptographic signature sealing the query and retrieved memory hashes. Each attestation is chained to the previous one via SHA-256 hash chains, creating a tamper-evident audit ledger verifiable by security teams.
+* **Automatic Secret Redaction**: Scans incoming log files and text writes to redact high-entropy secrets (API keys, JWTs, database strings, private keys) before they reach the persistent database.
+* **Reactive File Watching**: Integrates `chokidar` for instant event-driven scanning of agent transcript folders, guaranteeing that your memories are synchronized immediately after each agent interaction.
+
+*Read more in our compliance mapping guides:*
+- [SOC 2 Type II Controls](file:///c:/Users/Super/Desktop/Peryst/compliance/SOC2-controls.md)
+- [HIPAA Mapping & PHI Boundaries](file:///c:/Users/Super/Desktop/Peryst/compliance/HIPAA-mapping.md)
+- [EU AI Act Article 13 Transparency](file:///c:/Users/Super/Desktop/Peryst/compliance/EU-AI-Act-Article13.md)
+- [Compliance Audit Trail Sample](file:///c:/Users/Super/Desktop/Peryst/compliance/audit-trail-sample.md)
 
 ## How It Works
 
@@ -16,6 +31,14 @@ Your AI Agent ←→ MCP (stdio) ←→ Persyst ←→ SQLite (local)
 
 > 🚨 **First-Run Note**: On the first start, Persyst will automatically download the local embedding model (`all-MiniLM-L6-v2` ~50MB). This can take 30-60 seconds depending on your connection. The server will log `Loading embedding model...` and then proceed normally.
 
+### Passive Recording vs. Active Retrieval
+
+> ⚠️ **Honest Note on Agent Integration**: Persyst operates in two complementary modes:
+> 1. **Passive Recording**: The file watcher automatically extracts and saves memories from your agent conversation transcripts in the background.
+> 2. **Active Retrieval**: The AI agent calls `search_memories` or `get_optimized_context` to fetch relevant context.
+>
+> The IDE itself does not automatically inject retrieved memories into prompt inputs unless configured to do so via workspace rules (e.g. `.cursorrules`, `.windsurfrules`, `.agents/AGENTS.md`) or custom system prompt builders. To ensure the agent utilizes its memory, make sure your agent instructions direct it to query the database.
+
 ---
 
 ## Quick Start
@@ -116,6 +139,13 @@ Add Persyst to your Antigravity agent configuration file at `~/.gemini/antigravi
 | `delete_memory` | Delete a memory and clean up edges | `id` (number) |
 | `get_recent_memories` | Get latest memories | `limit` (number) |
 | `get_important_memories` | Get by importance score | `limit` (number) |
+| `get_optimized_context` | Get compressed, ranked context block | `query` (string), `max_tokens` (number) |
+| `ingest_git_commits` | Import recent git commits as memories | `repo_path` (string), `count` (number) |
+| `consolidate_memories` | Merge highly similar duplicate memories | — |
+| `get_memory_history` | Retrieve all versions of a memory | `query` (string) |
+| `get_agent_stats` | Agent reputation stats | — |
+| `export_audit_log` | Export attestation audit log | `start_date`, `end_date` (ISO8601) |
+| `verify_attestation` | Verify Ed25519 signature chain | `attestation_id` (string) |
 
 ---
 
@@ -159,6 +189,38 @@ Do not run `npx` with `sudo`. If you run into permission issues, ensure your npm
 
 ---
 
+## Backup & Migration
+
+Persyst includes built-in JSONL export/import commands for portable memory backup and cross-machine migration.
+
+```bash
+# Export all memories to a file
+npx persyst-mcp export
+# → persyst-export-<timestamp>.jsonl
+
+# Export to a specific file
+npx persyst-mcp export my-backup.jsonl
+
+# Preview what would be imported (dry run)
+npx persyst-mcp import my-backup.jsonl --dry-run
+
+# Import memories (skips exact & semantic duplicates automatically)
+npx persyst-mcp import my-backup.jsonl
+```
+
+---
+
+## Roadmap & Future Directions
+
+Persyst is built for the privacy-focused solo developer. We are actively hardening the local-first experience before introducing network dependencies.
+
+* **File-Based Sync** ✅ **Done**: `persyst-export` / `persyst-import` JSONL commands for backup and migration.
+* **IDE Integrations**: First-class extensions for Cursor, VS Code, and Aider configuration helper commands.
+* **True P2P Sync (Roadmap)**: Peer-to-peer secure sync between developer devices without relying on central cloud servers.
+
+---
+
 ## License
 
 MIT License. See [LICENSE](LICENSE) for details.
+

package/bin/export.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * export.js — Persyst Memory JSONL Export CLI
+ *
+ * Exports all active memories to a portable JSONL file for backup or migration.
+ * Each line is a JSON object representing one memory with its full metadata.
+ *
+ * Usage:
+ *   persyst-export                          → exports to persyst-export-<timestamp>.jsonl
+ *   persyst-export memories.jsonl           → exports to memories.jsonl
+ *   persyst-export --namespace=shared       → exports only the shared namespace
+ *   persyst-export --all                    → includes archived (valid_until IS NOT NULL) memories
+ *
+ * The output format is designed to be imported back via `persyst-import`.
+ */
+
+import { createWriteStream } from 'fs';
+import db, { closeDatabase } from '../src/database.js';
+
+// ============================================================
+// ARG PARSING
+// ============================================================
+
+const args = process.argv.slice(2);
+const outputFile = args.find(a => !a.startsWith('--')) || `persyst-export-${Date.now()}.jsonl`;
+const namespace = (args.find(a => a.startsWith('--namespace=')) || '').replace('--namespace=', '') || null;
+const includeArchived = args.includes('--all');
+
+// ============================================================
+// EXPORT
+// ============================================================
+
+try {
+  const conditions = [];
+  const params = [];
+
+  if (!includeArchived) {
+    conditions.push('m.valid_until IS NULL');
+  }
+  if (namespace) {
+    conditions.push("(m.namespace = ? OR m.namespace = 'shared')");
+    params.push(namespace);
+  }
+
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+  const query = `
+    SELECT
+      m.id,
+      m.content,
+      m.importance_score,
+      m.namespace,
+      m.created_at,
+      m.last_accessed,
+      m.access_count,
+      m.parent_id,
+      m.valid_until,
+      p.source_type,
+      p.source_id,
+      p.confidence
+    FROM memories m
+    LEFT JOIN provenance p ON p.memory_id = m.id
+    ${whereClause}
+    ORDER BY m.id ASC
+  `;
+
+  const rows = params.length > 0 ? db.prepare(query).all(...params) : db.prepare(query).all();
+
+  const out = createWriteStream(outputFile, { encoding: 'utf8' });
+
+  let count = 0;
+  for (const row of rows) {
+    const record = {
+      id: row.id,
+      content: row.content,
+      importance_score: row.importance_score,
+      namespace: row.namespace || 'shared',
+      created_at: row.created_at,
+      last_accessed: row.last_accessed,
+      access_count: row.access_count,
+      parent_id: row.parent_id ?? null,
+      valid_until: row.valid_until ?? null,
+      provenance: row.source_type
+        ? {
+            source_type: row.source_type,
+            source_id: row.source_id ?? null,
+            confidence: row.confidence ?? 1.0
+          }
+        : null
+    };
+    out.write(JSON.stringify(record) + '\n');
+    count++;
+  }
+
+  await new Promise((resolve, reject) => {
+    out.end((err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+
+  console.log(`✅ Exported ${count} memories to: ${outputFile}`);
+  if (namespace) {
+    console.log(`   Namespace filter: "${namespace}" + shared`);
+  }
+  if (includeArchived) {
+    console.log('   Includes archived (superseded) memories.');
+  }
+
+} catch (err) {
+  console.error(`❌ Export failed: ${err.message}`);
+  process.exit(1);
+} finally {
+  closeDatabase();
+}

package/bin/import.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+/**
+ * import.js — Persyst Memory JSONL Import CLI
+ *
+ * Imports memories from a JSONL file created by `persyst-export`.
+ * Regenerates vector embeddings for each imported memory.
+ * Skips duplicates using both exact-content and semantic similarity checks.
+ *
+ * Usage:
+ *   persyst-import memories.jsonl
+ *   persyst-import memories.jsonl --dry-run          → preview without writing
+ *   persyst-import memories.jsonl --namespace=shared  → force all into shared namespace
+ *   persyst-import memories.jsonl --skip-embeddings   → skip re-generating embeddings (fast, no semantic search for these)
+ *
+ * Compatible with the JSONL format produced by `persyst-export`.
+ */
+
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+import db, {
+  insertMemory,
+  insertVector,
+  memoryExists,
+  closeDatabase
+} from '../src/database.js';
+import { generateEmbedding } from '../src/embeddings.js';
+import { searchHybrid } from '../src/search.js';
+
+// ============================================================
+// ARG PARSING
+// ============================================================
+
+const args = process.argv.slice(2);
+const inputFile = args.find(a => !a.startsWith('--'));
+const isDryRun = args.includes('--dry-run');
+const forceNamespace = (args.find(a => a.startsWith('--namespace=')) || '').replace('--namespace=', '') || null;
+const skipEmbeddings = args.includes('--skip-embeddings');
+
+const DEDUP_THRESHOLD = 0.85;
+
+if (!inputFile) {
+  console.error('❌ Usage: persyst-import <file.jsonl> [--dry-run] [--namespace=<ns>] [--skip-embeddings]');
+  process.exit(1);
+}
+
+// ============================================================
+// MAIN
+// ============================================================
+
+async function main() {
+  console.log(`📥 Persyst Import${isDryRun ? ' (DRY RUN — nothing will be written)' : ''}`);
+  console.log(`   Source: ${inputFile}`);
+  if (forceNamespace) console.log(`   Forcing namespace: "${forceNamespace}"`);
+  if (skipEmbeddings) console.log('   Skipping embedding regeneration.');
+  console.log('');
+
+  const rl = createInterface({
+    input: createReadStream(inputFile, { encoding: 'utf8' }),
+    crlfDelay: Infinity
+  });
+
+  let lineNum = 0;
+  let imported = 0;
+  let skipped = 0;
+  let errors = 0;
+
+  for await (const line of rl) {
+    lineNum++;
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    let record;
+    try {
+      record = JSON.parse(trimmed);
+    } catch (err) {
+      console.error(`  ⚠️  Line ${lineNum}: Invalid JSON — skipping`);
+      errors++;
+      continue;
+    }
+
+    const { content, importance_score = 1.0, namespace, provenance, valid_until } = record;
+
+    if (!content || typeof content !== 'string' || content.trim().length === 0) {
+      console.error(`  ⚠️  Line ${lineNum}: Empty content — skipping`);
+      errors++;
+      continue;
+    }
+
+    // Skip archived memories (unless they have a parent_id, we skip them anyway)
+    if (valid_until !== null && valid_until !== undefined) {
+      skipped++;
+      continue;
+    }
+
+    const targetNamespace = forceNamespace || namespace || 'shared';
+
+    // --- Dedup: exact content match ---
+    if (memoryExists(content, targetNamespace)) {
+      console.log(`  ⏭️  Line ${lineNum}: Already exists — skipping "${content.slice(0, 60)}..."`);
+      skipped++;
+      continue;
+    }
+
+    // --- Dedup: semantic similarity ---
+    if (!skipEmbeddings) {
+      try {
+        const similar = await searchHybrid(content, 1, null, null, targetNamespace);
+        if (similar.length > 0 && parseFloat(similar[0].similarity) >= DEDUP_THRESHOLD) {
+          console.log(`  ⏭️  Line ${lineNum}: Semantically similar to #${similar[0].id} (sim=${similar[0].similarity}) — skipping`);
+          skipped++;
+          continue;
+        }
+      } catch (_) {
+        // Non-critical: proceed with import if semantic check fails
+      }
+    }
+
+    if (isDryRun) {
+      console.log(`  ✅ Would import: "${content.slice(0, 80)}${content.length > 80 ? '...' : ''}" → ns="${targetNamespace}"`);
+      imported++;
+      continue;
+    }
+
+    // --- Write to DB ---
+    try {
+      const prov = provenance || { source_type: 'import', source_id: 'persyst-import', confidence: 1.0 };
+      const id = insertMemory(content, importance_score, prov, targetNamespace);
+
+      if (!skipEmbeddings) {
+        const embedding = await generateEmbedding(content);
+        insertVector(id, embedding);
+      }
+
+      console.log(`  ✅ Imported #${id}: "${content.slice(0, 70)}${content.length > 70 ? '...' : ''}"`);
+      imported++;
+    } catch (err) {
+      console.error(`  ❌ Line ${lineNum}: Failed to insert — ${err.message}`);
+      errors++;
+    }
+  }
+
+  console.log('');
+  console.log('═'.repeat(50));
+  if (isDryRun) {
+    console.log(`📊 Dry run complete: ${imported} would import, ${skipped} skipped, ${errors} errors`);
+  } else {
+    console.log(`📊 Import complete: ${imported} imported, ${skipped} skipped, ${errors} errors`);
+  }
+  console.log('═'.repeat(50));
+}
+
+main()
+  .catch(err => {
+    console.error(`❌ Import crashed: ${err.message}`);
+    process.exit(1);
+  })
+  .finally(() => {
+    closeDatabase();
+  });

package/bin/init.js

@@ -1,30 +1,33 @@
 #!/usr/bin/env node
 
 /**
- * persyst-init — Workspace rules generator for VS Code-based IDEs (Cursor, Windsurf, Antigravity)
+ * persyst-init — Workspace rules generator and global IDE configuration builder
  * 
  * Usage:
  *   npx persyst-mcp init
+ *   npx persyst-mcp init --mcp cursor,aider
  * 
  * What it does:
- *   1. Safely creates or appends system instructions to `.cursorrules`
- *   2. Safely creates or appends system instructions to `.windsurfrules`
- *   3. Creates a general `.persystrules.md` copy-pasteable guide
- *   4. Prints instructions on configuring MCP servers in Cursor/VS Code/Antigravity
- * 
- * Design:
- *   - Non-destructive: checks for existing content before appending to avoid duplication
- *   - Idempotent: safe to run multiple times
- *   - Localized: targets the current working directory (project root)
+ *   1. Safely creates or appends system instructions to `.cursorrules` and `.windsurfrules`
+ *   2. Creates a general `.persystrules.md` workspace guide
+ *   3. Configures Git post-commit hook for auto-ingestion
+ *   4. Generates cryptographic Ed25519 keys inside ~/.persyst
+ *   5. Automatically detects and configures global settings for Cursor, Aider, Claude Code, and Continue
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from 'fs';
 import { join, resolve, dirname } from 'path';
+import { homedir } from 'os';
 import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { initializeKeys } from '../src/attestation.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const CONFIG_DIR = join(homedir(), '.persyst');
+const PERSYST_DB = join(CONFIG_DIR, 'persyst.db');
+
 // ============================================================
 // SYSTEM INSTRUCTION CONTENT
 // ============================================================
@@ -46,6 +49,10 @@ You are integrated with Persyst, a local-first MCP memory server that stores use
 - Handle Contradictions: Persyst handles contradiction detection automatically. If a new fact contradicts an old memory, Persyst will flag it.
 - Quality Over Quantity: Do NOT store trivial facts, temporary conversation noise, or duplicate data. "Bad data is worse than no data". Only store long-term architecture decisions, project details, and explicit user preferences.
 
+## Explicit User Save Requests
+- If the user explicitly asks you to remember, save, or keep a note of a fact (e.g., "Remember that John handles deployment", "remind me that staging is flaky"), call the \`add_memory\` tool immediately with that content.
+- Bypassing Tech Filters: Explicit user requests bypass the programming keyword filters. Ensure they are captured verbatim.
+
 ## Mandatory Completion Checklist (HARD CONSTRAINT)
 Before writing your final response declaring a task, feature, or bug fix complete:
 1. Ask yourself: "Did I implement a feature, fix a bug, configure a tool, or discover a project rule?"
@@ -82,7 +89,7 @@ ${RULE_CONTENT.trim()}
 `;
 
 // ============================================================
-// HELPERS
+// WORKSPACE HELPERS
 // ============================================================
 
 function setupRuleFile(filePath, fileName) {
@@ -104,33 +111,153 @@ function setupRuleFile(filePath, fileName) {
 }
 
 // ============================================================
-// MAIN
+// GLOBAL CONFIG WRITERS
+// ============================================================
+
+function detectEditors() {
+  const editors = [];
+  const home = homedir();
+  
+  // Cursor
+  const cursorDir = join(home, '.cursor');
+  const winCursorDir = join(home, 'AppData', 'Roaming', 'Cursor');
+  if (existsSync(cursorDir) || existsSync(winCursorDir) || existsSync('/Applications/Cursor.app') || existsSync(join(home, 'AppData', 'Local', 'Programs', 'cursor'))) {
+    editors.push('cursor');
+  }
+  
+  // Aider
+  try {
+    execSync('aider --version', { stdio: 'ignore' });
+    editors.push('aider');
+  } catch (_) {}
+  
+  // Claude Code
+  const claudeDir = join(home, '.claude');
+  if (existsSync(claudeDir) || existsSync('/Applications/Claude Code.app')) {
+    editors.push('claude-code');
+  }
+  
+  // Continue.dev
+  const continueConfig = join(home, '.continue', 'config.json');
+  if (existsSync(continueConfig)) {
+    editors.push('continue');
+  }
+  
+  return editors;
+}
+
+function writeCursorConfig() {
+  const cursorMcp = join(homedir(), '.cursor', 'mcp.json');
+  try {
+    const config = existsSync(cursorMcp) ? JSON.parse(readFileSync(cursorMcp, 'utf8')) : {};
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers.persyst = {
+      "command": "npx",
+      "args": ["-y", "persyst-mcp"],
+      "env": { "PERSYST_DB": PERSYST_DB }
+    };
+    mkdirSync(dirname(cursorMcp), { recursive: true });
+    writeFileSync(cursorMcp, JSON.stringify(config, null, 2));
+    console.log('     ✅ Cursor MCP config written to ~/.cursor/mcp.json');
+  } catch (err) {
+    console.error(`     ✗ Failed to configure Cursor: ${err.message}`);
+  }
+}
+
+function writeAiderConfig() {
+  const aiderYml = join(homedir(), '.aider.conf.yml');
+  try {
+    let content = '';
+    if (existsSync(aiderYml)) {
+      content = readFileSync(aiderYml, 'utf8');
+    }
+    if (!content.includes('persyst')) {
+      content += `\n# Persyst MCP integration\nmcp:\n  - name: persyst\n    cmd: npx\n    args: ["-y", "persyst-mcp"]\n    env:\n      PERSYST_DB: ${PERSYST_DB}\n`;
+      writeFileSync(aiderYml, content);
+      console.log('     ✅ Aider MCP config appended to ~/.aider.conf.yml');
+    } else {
+      console.log('     ℹ️  Aider already has Persyst configured (skipped).');
+    }
+  } catch (err) {
+    console.error(`     ✗ Failed to configure Aider: ${err.message}`);
+  }
+}
+
+function writeClaudeCodeConfig() {
+  const claudeJson = join(homedir(), '.claude.json');
+  try {
+    const config = existsSync(claudeJson) ? JSON.parse(readFileSync(claudeJson, 'utf8')) : {};
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers.persyst = {
+      "command": "npx",
+      "args": ["-y", "persyst-mcp"],
+      "env": { "PERSYST_DB": PERSYST_DB }
+    };
+    writeFileSync(claudeJson, JSON.stringify(config, null, 2));
+    console.log('     ✅ Claude Code MCP config written to ~/.claude.json');
+  } catch (err) {
+    console.error(`     ✗ Failed to configure Claude Code: ${err.message}`);
+  }
+}
+
+function writeContinueConfig() {
+  const continueConfig = join(homedir(), '.continue', 'config.json');
+  try {
+    const config = existsSync(continueConfig) ? JSON.parse(readFileSync(continueConfig, 'utf8')) : {};
+    config.mcpServers = config.mcpServers || [];
+    // Remove existing persyst entry
+    config.mcpServers = config.mcpServers.filter(s => s.name !== 'persyst');
+    config.mcpServers.push({
+      "name": "persyst",
+      "command": "npx",
+      "args": ["-y", "persyst-mcp"],
+      "env": { "PERSYST_DB": PERSYST_DB }
+    });
+    mkdirSync(dirname(continueConfig), { recursive: true });
+    writeFileSync(continueConfig, JSON.stringify(config, null, 2));
+    console.log('     ✅ Continue.dev MCP config written to ~/.continue/config.json');
+  } catch (err) {
+    console.error(`     ✗ Failed to configure Continue.dev: ${err.message}`);
+  }
+}
+
+// ============================================================
+// MAIN RUNNER
 // ============================================================
 
 function run() {
   console.log('');
-  console.log('  🧠 Persyst — Workspace Rules Setup');
-  console.log('  ════════════════════════════════════');
+  console.log('  🧠 Persyst — Workspace & Editor Setup');
+  console.log('  ══════════════════════════════════════');
   console.log('');
 
   const cwd = process.cwd();
   console.log(`  📁 Target workspace: ${cwd}`);
-  console.log('');
 
-  // 1. Create/Append Cursor Rules
+  // 1. Initialize local configuration folder and attestations
+  console.log('  ⚙️  Initializing keypairs & DB folders...');
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  initializeKeys();
+  console.log('     ✅ Cryptographic keypairs generated');
+
+  // 2. Local workspace configurations
+  console.log('');
+  console.log('  📄 Initializing workspace rule files...');
+  
   const cursorRulesPath = join(cwd, '.cursorrules');
   setupRuleFile(cursorRulesPath, '.cursorrules');
 
-  // 2. Create/Append Windsurf Rules
   const windsurfRulesPath = join(cwd, '.windsurfrules');
   setupRuleFile(windsurfRulesPath, '.windsurfrules');
 
-  // 3. Create General Guide File
+  const clineRulesPath = join(cwd, '.clinerules');
+  setupRuleFile(clineRulesPath, '.clinerules');
+
   const generalGuidePath = join(cwd, '.persystrules.md');
   writeFileSync(generalGuidePath, GENERAL_GUIDE.trim() + '\n', 'utf8');
   console.log('     ✅ Created .persystrules.md (General Guide)');
 
-  // 4. Configure Git post-commit hook for automatic commit ingestion
+  // 3. Git post-commit hook
   const gitDir = join(cwd, '.git');
   if (existsSync(gitDir)) {
     const hooksDir = join(gitDir, 'hooks');
@@ -159,22 +286,31 @@ fi
     console.log('     ✅ Configured Git post-commit hook for auto-ingestion');
   }
 
-  // 5. Print Success & Configuration Help
+  // 4. Global editor configurations
   console.log('');
-  console.log('  ════════════════════════════════════');
-  console.log('  ✅ Rules and Git hooks initialization complete!');
+  console.log('  💻 Initializing global IDE configurations...');
+  
+  const args = process.argv.slice(2);
+  const mcpFlag = args.find(a => a.startsWith('--mcp='));
+  const requestedEditors = mcpFlag ? mcpFlag.split('=')[1].split(',') : [];
+  
+  const editors = requestedEditors.length > 0 ? requestedEditors : detectEditors();
+  console.log(`     Detected editors/environments: ${editors.join(', ') || 'none'}`);
+
+  if (editors.includes('cursor')) writeCursorConfig();
+  if (editors.includes('aider')) writeAiderConfig();
+  if (editors.includes('claude-code')) writeClaudeCodeConfig();
+  if (editors.includes('continue')) writeContinueConfig();
+
+  // 5. Final self-test and notes
   console.log('');
-  console.log('  To connect the memory server to Cursor, Antigravity, or VS Code:');
-  console.log('    1. Open your IDE Settings -> MCP (Model Context Protocol).');
-  console.log('    2. Add a new command server:');
-  console.log('         • Name:      persyst');
-  console.log('         • Command:   npx');
-  console.log('         • Arguments: -y persyst-mcp');
+  console.log('  ══════════════════════════════════════');
+  console.log('  🎉 Setup complete! Persyst is fully configured.');
   console.log('');
-  console.log('  The rules we generated will guide the AI agents in this workspace to:');
-  console.log('    • Proactively search memory before answering prompts.');
-  console.log('    • Log milestone achievements and user preferences.');
-  console.log('    • Keep the memory clean ("no bad data").');
+  console.log('  Next steps:');
+  console.log('    1. Restart your editor to load the new MCP configurations.');
+  console.log('    2. Test gateway connection:');
+  console.log('         curl http://127.0.0.1:4321/health');
   console.log('');
 }
 

package/bin/mcp.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startServer } from '../src/server.js';
+
+startServer().catch(err => {
+  console.error('❌ Persyst failed to start:', err.message);
+  process.exit(1);
+});