@synth-coder/memhub 0.2.2 → 0.2.4

package/src/storage/vector-index.ts

@@ -15,7 +15,7 @@ const TABLE_NAME = 'memories';
 
 /** Escape single quotes in id strings to prevent SQL injection */
 function escapeId(id: string): string {
-    return id.replace(/'/g, "''");
+  return id.replace(/'/g, "''");
 }
 
 /**
@@ -23,20 +23,20 @@ function escapeId(id: string): string {
  * The `vector` field is the only one required by LanceDB; all others are metadata filters.
  */
 export interface VectorRow {
-    id: string;
-    vector: number[];
-    title: string;
-    category: string;
-    tags: string; // JSON-serialised string[]
-    importance: number;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  vector: number[];
+  title: string;
+  category: string;
+  tags: string; // JSON-serialised string[]
+  importance: number;
+  createdAt: string;
+  updatedAt: string;
 }
 
 export interface VectorSearchResult {
-    id: string;
-    /** Cosine distance (lower = more similar). Converted to 0-1 score by caller. */
-    _distance: number;
+  id: string;
+  /** Cosine distance (lower = more similar). Converted to 0-1 score by caller. */
+  _distance: number;
 }
 
 /**
@@ -44,117 +44,116 @@ export interface VectorSearchResult {
  * Data lives at `{storagePath}/.lancedb/`.
  */
 export class VectorIndex {
-    private readonly dbPath: string;
-    private db: lancedb.Connection | null = null;
-    private table: lancedb.Table | null = null;
-    private initPromise: Promise<void> | null = null;
+  private readonly dbPath: string;
+  private db: lancedb.Connection | null = null;
+  private table: lancedb.Table | null = null;
+  private initPromise: Promise<void> | null = null;
 
-    constructor(storagePath: string) {
-        this.dbPath = join(storagePath, '.lancedb');
-    }
-
-    /** Idempotent initialisation — safe to call multiple times. */
-    async initialize(): Promise<void> {
-        if (this.table) return;
-
-        if (!this.initPromise) {
-            this.initPromise = this._init();
-        }
-        await this.initPromise;
-    }
+  constructor(storagePath: string) {
+    this.dbPath = join(storagePath, '.lancedb');
+  }
 
-    private async _init(): Promise<void> {
-        // Ensure the directory exists
-        try {
-            await access(this.dbPath, constants.F_OK);
-        } catch {
-            await mkdir(this.dbPath, { recursive: true });
-        }
-
-        this.db = await lancedb.connect(this.dbPath);
-
-        const existingTables = await this.db.tableNames();
-        if (existingTables.includes(TABLE_NAME)) {
-            this.table = await this.db.openTable(TABLE_NAME);
-        } else {
-            // Create table with a dummy row so schema is established, then delete it
-            const dummy: VectorRow = {
-                id: '__init__',
-                vector: new Array(384).fill(0) as number[],
-                title: '',
-                category: '',
-                tags: '[]',
-                importance: 0,
-                createdAt: '',
-                updatedAt: '',
-            };
-            // LanceDB expects Record<string, unknown>[] but our VectorRow is typed more strictly
-            // Cast is safe here as VectorRow is a subset of Record<string, unknown>
-            this.table = await this.db.createTable(TABLE_NAME, [dummy as unknown as Record<string, unknown>]);
-            await this.table.delete(`id = '__init__'`);
-        }
-    }
-
-    /**
-     * Upserts a memory row into the index.
-     * LanceDB doesn't have a native upsert so we delete-then-add.
-     */
-    async upsert(memory: Memory, vector: number[]): Promise<void> {
-        await this.initialize();
-        const table = this.table!;
-
-        // Remove existing row (if any)
-        await table.delete(`id = '${escapeId(memory.id)}'`);
-
-        const row: VectorRow = {
-            id: memory.id,
-            vector,
-            title: memory.title,
-            category: memory.category,
-            tags: JSON.stringify(memory.tags),
-            importance: memory.importance,
-            createdAt: memory.createdAt,
-            updatedAt: memory.updatedAt,
-        };
-
-        // LanceDB expects Record<string, unknown>[] but our VectorRow is typed more strictly
-        await table.add([row as unknown as Record<string, unknown>]);
-    }
+  /** Idempotent initialisation — safe to call multiple times. */
+  async initialize(): Promise<void> {
+    if (this.table) return;
 
-    /**
-     * Removes a memory from the index by ID.
-     */
-    async delete(id: string): Promise<void> {
-        await this.initialize();
-        await this.table!.delete(`id = '${escapeId(id)}'`);
+    if (!this.initPromise) {
+      this.initPromise = this._init();
     }
-
-    /**
-     * Searches for the nearest neighbours to `vector`.
-     *
-     * @param vector - Query embedding (must be 384-dim)
-     * @param limit  - Max results to return
-     * @returns Array ordered by ascending distance (most similar first)
-     */
-    async search(vector: number[], limit = 10): Promise<VectorSearchResult[]> {
-        await this.initialize();
-
-        const results = await this.table!
-            .vectorSearch(vector)
-            .limit(limit)
-            .toArray();
-
-        return results.map((row: Record<string, unknown>) => ({
-            id: row['id'] as string,
-            _distance: row['_distance'] as number,
-        }));
+    await this.initPromise;
+  }
+
+  private async _init(): Promise<void> {
+    // Ensure the directory exists
+    try {
+      await access(this.dbPath, constants.F_OK);
+    } catch {
+      await mkdir(this.dbPath, { recursive: true });
     }
 
-    /**
-     * Returns the number of rows in the index.
-     */
-    async count(): Promise<number> {
-        await this.initialize();
-        return this.table!.countRows();
+    this.db = await lancedb.connect(this.dbPath);
+
+    const existingTables = await this.db.tableNames();
+    if (existingTables.includes(TABLE_NAME)) {
+      this.table = await this.db.openTable(TABLE_NAME);
+    } else {
+      // Create table with a dummy row so schema is established, then delete it
+      const dummy: VectorRow = {
+        id: '__init__',
+        vector: new Array(384).fill(0) as number[],
+        title: '',
+        category: '',
+        tags: '[]',
+        importance: 0,
+        createdAt: '',
+        updatedAt: '',
+      };
+      // LanceDB expects Record<string, unknown>[] but our VectorRow is typed more strictly
+      // Cast is safe here as VectorRow is a subset of Record<string, unknown>
+      this.table = await this.db.createTable(TABLE_NAME, [
+        dummy as unknown as Record<string, unknown>,
+      ]);
+      await this.table.delete(`id = '__init__'`);
     }
+  }
+
+  /**
+   * Upserts a memory row into the index.
+   * LanceDB doesn't have a native upsert so we delete-then-add.
+   */
+  async upsert(memory: Memory, vector: number[]): Promise<void> {
+    await this.initialize();
+    const table = this.table!;
+
+    // Remove existing row (if any)
+    await table.delete(`id = '${escapeId(memory.id)}'`);
+
+    const row: VectorRow = {
+      id: memory.id,
+      vector,
+      title: memory.title,
+      category: memory.category,
+      tags: JSON.stringify(memory.tags),
+      importance: memory.importance,
+      createdAt: memory.createdAt,
+      updatedAt: memory.updatedAt,
+    };
+
+    // LanceDB expects Record<string, unknown>[] but our VectorRow is typed more strictly
+    await table.add([row as unknown as Record<string, unknown>]);
+  }
+
+  /**
+   * Removes a memory from the index by ID.
+   */
+  async delete(id: string): Promise<void> {
+    await this.initialize();
+    await this.table!.delete(`id = '${escapeId(id)}'`);
+  }
+
+  /**
+   * Searches for the nearest neighbours to `vector`.
+   *
+   * @param vector - Query embedding (must be 384-dim)
+   * @param limit  - Max results to return
+   * @returns Array ordered by ascending distance (most similar first)
+   */
+  async search(vector: number[], limit = 10): Promise<VectorSearchResult[]> {
+    await this.initialize();
+
+    const results = await this.table!.vectorSearch(vector).limit(limit).toArray();
+
+    return results.map((row: Record<string, unknown>) => ({
+      id: row['id'] as string,
+      _distance: row['_distance'] as number,
+    }));
+  }
+
+  /**
+   * Returns the number of rows in the index.
+   */
+  async count(): Promise<number> {
+    await this.initialize();
+    return this.table!.countRows();
+  }
 }

package/test/cli/init.test.ts

@@ -0,0 +1,380 @@
+/**
+ * Tests for CLI init command
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { initAgent } from '../../src/cli/init.js';
+import { AGENTS, type AgentType } from '../../src/cli/types.js';
+import {
+  extractMemHubVersion,
+  needsUpdate,
+  updateInstructionsContent,
+} from '../../src/cli/instructions.js';
+
+const TEST_DIR = join(process.cwd(), 'test-temp-cli');
+
+describe('CLI Init Command', () => {
+  beforeEach(() => {
+    if (!existsSync(TEST_DIR)) {
+      mkdirSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe('initAgent', () => {
+    it('should create local config and instructions for cursor', () => {
+      const result = initAgent({
+        agent: 'cursor',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('cursor');
+        expect(result.configPath).toBe('.cursor/mcp.json');
+        expect(result.instructionsPath).toBe('.cursorrules');
+        expect(existsSync(join(TEST_DIR, '.cursor/mcp.json'))).toBe(true);
+        expect(existsSync(join(TEST_DIR, '.cursorrules'))).toBe(true);
+      }
+    });
+
+    it('should create local config and instructions for claude-code', () => {
+      const result = initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('claude-code');
+        expect(result.configPath).toBe('.mcp.json');
+        expect(result.instructionsPath).toBe('CLAUDE.md');
+      }
+    });
+
+    it('should create local config and instructions for cline', () => {
+      const result = initAgent({
+        agent: 'cline',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('cline');
+        expect(result.configPath).toBe('.cline/mcp.json');
+        expect(result.instructionsPath).toBe('.clinerules');
+      }
+    });
+
+    it('should create local config and instructions for windsurf', () => {
+      const result = initAgent({
+        agent: 'windsurf',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('windsurf');
+        expect(result.configPath).toBe('.codeium/windsurf/mcp_config.json');
+        expect(result.instructionsPath).toBe('.windsurfrules');
+      }
+    });
+
+    it('should create local config and instructions for factory-droid', () => {
+      const result = initAgent({
+        agent: 'factory-droid',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('factory-droid');
+        expect(result.configPath).toBe('.factory/mcp.json');
+        expect(result.instructionsPath).toBe('.factory/AGENTS.md');
+      }
+    });
+
+    it('should create local config and instructions for gemini-cli', () => {
+      const result = initAgent({
+        agent: 'gemini-cli',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('gemini-cli');
+        expect(result.configPath).toBe('.gemini/settings.json');
+        expect(result.instructionsPath).toBe('GEMINI.md');
+      }
+    });
+
+    it('should create local config and instructions for codex', () => {
+      const result = initAgent({
+        agent: 'codex',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.agent.id).toBe('codex');
+        expect(result.configPath).toBe('.codex/config.toml');
+        expect(result.instructionsPath).toBe('AGENTS.md');
+        expect(existsSync(join(TEST_DIR, '.codex/config.toml'))).toBe(true);
+        expect(existsSync(join(TEST_DIR, 'AGENTS.md'))).toBe(true);
+      }
+    });
+
+    it('should fail for unknown agent', () => {
+      const result = initAgent({
+        agent: 'unknown-agent' as AgentType,
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('Unknown agent');
+      }
+    });
+
+    it('should fail if memhub already configured without force', () => {
+      // First init
+      initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      // Second init without force
+      const result = initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+        force: false,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('already configured');
+      }
+    });
+
+    it('should update config with force', () => {
+      // First init
+      initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      // Second init with force
+      const result = initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+        force: true,
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should generate valid JSON config', () => {
+      initAgent({
+        agent: 'cursor',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      const configPath = join(TEST_DIR, '.cursor/mcp.json');
+      const content = readFileSync(configPath, 'utf-8');
+      const config = JSON.parse(content);
+
+      expect(config).toHaveProperty('mcpServers');
+      expect(config.mcpServers).toHaveProperty('memhub');
+      expect(config.mcpServers.memhub).toHaveProperty('command');
+      expect(config.mcpServers.memhub.command).toBe('npx');
+    });
+
+    it('should generate instructions with version tag', () => {
+      initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      const instructionsPath = join(TEST_DIR, 'CLAUDE.md');
+      const content = readFileSync(instructionsPath, 'utf-8');
+
+      expect(content).toContain('<!-- MEMHUB:v');
+      expect(content).toContain('<!-- MEMHUB:END -->');
+    });
+
+    it('should merge with existing config preserving other servers', () => {
+      // Create existing config with other servers
+      const configDir = join(TEST_DIR, '.mcp.json');
+      const existingConfig = {
+        mcpServers: {
+          github: {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-github'],
+          },
+        },
+      };
+      writeFileSync(configDir, JSON.stringify(existingConfig, null, 2), 'utf-8');
+
+      // Run init
+      const result = initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify both servers exist
+      const content = readFileSync(configDir, 'utf-8');
+      const config = JSON.parse(content);
+
+      expect(config.mcpServers).toHaveProperty('github');
+      expect(config.mcpServers).toHaveProperty('memhub');
+    });
+
+    it('should fail if memhub already in config without force', () => {
+      // Create config with memhub already configured
+      const configDir = join(TEST_DIR, '.mcp.json');
+      const existingConfig = {
+        mcpServers: {
+          memhub: {
+            command: 'npx',
+            args: ['-y', '@synth-coder/memhub'],
+          },
+        },
+      };
+      writeFileSync(configDir, JSON.stringify(existingConfig, null, 2), 'utf-8');
+
+      // Run init without force
+      const result = initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+        force: false,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('already configured');
+      }
+    });
+
+    it('should update memhub with force preserving other servers', () => {
+      // Create config with existing servers including memhub
+      const configDir = join(TEST_DIR, '.mcp.json');
+      const existingConfig = {
+        mcpServers: {
+          github: {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-github'],
+          },
+          memhub: {
+            command: 'old-command',
+            args: [],
+          },
+        },
+      };
+      writeFileSync(configDir, JSON.stringify(existingConfig, null, 2), 'utf-8');
+
+      // Run init with force
+      const result = initAgent({
+        agent: 'claude-code',
+        local: true,
+        projectPath: TEST_DIR,
+        force: true,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify github preserved, memhub updated
+      const content = readFileSync(configDir, 'utf-8');
+      const config = JSON.parse(content);
+
+      expect(config.mcpServers).toHaveProperty('github');
+      expect(config.mcpServers).toHaveProperty('memhub');
+      expect(config.mcpServers.memhub.command).toBe('npx');
+    });
+  });
+
+  describe('Instructions Update', () => {
+    it('should prepend instructions to empty file', () => {
+      const result = updateInstructionsContent('', AGENTS[1]); // claude-code
+
+      expect(result.updated).toBe(true);
+      expect(result.content).toContain('<!-- MEMHUB:v');
+    });
+
+    it('should prepend instructions to existing content', () => {
+      const existing = '# My Project\n\nSome instructions';
+      const result = updateInstructionsContent(existing, AGENTS[1]);
+
+      expect(result.updated).toBe(true);
+      expect(result.content).toContain('<!-- MEMHUB:v');
+      expect(result.content).toContain('# My Project');
+    });
+
+    it('should not update if already current version', () => {
+      const content = '<!-- MEMHUB:v0.2.3:START -->\nContent\n<!-- MEMHUB:END -->';
+      const result = updateInstructionsContent(content, AGENTS[1]);
+
+      expect(result.updated).toBe(false);
+      expect(result.reason).toBe('Already up to date');
+    });
+
+    it('should extract version correctly', () => {
+      expect(extractMemHubVersion('<!-- MEMHUB:v0.2.3:START -->')).toBe('0.2.3');
+      expect(extractMemHubVersion('No version here')).toBeNull();
+    });
+
+    it('should detect when update is needed', () => {
+      expect(needsUpdate('No MemHub content')).toBe(true);
+      expect(needsUpdate('<!-- MEMHUB:v0.1.0:START -->')).toBe(true);
+    });
+  });
+});
+
+describe('Agent Types', () => {
+  it('should have all expected agents', () => {
+    const agentIds = AGENTS.map(a => a.id);
+    expect(agentIds).toContain('cursor');
+    expect(agentIds).toContain('claude-code');
+    expect(agentIds).toContain('cline');
+    expect(agentIds).toContain('windsurf');
+    expect(agentIds).toContain('factory-droid');
+    expect(agentIds).toContain('gemini-cli');
+    expect(agentIds).toContain('codex');
+  });
+
+  it('should have valid config for each agent', () => {
+    AGENTS.forEach(agent => {
+      expect(agent.configFile).toBeTruthy();
+      expect(agent.globalConfigFile).toBeTruthy();
+      expect(agent.name).toBeTruthy();
+      expect(agent.configFormat).toMatch(/^(json|markdown|toml)$/);
+      expect(agent.instructionsFile).toBeTruthy();
+      expect(agent.globalInstructionsFile).toBeTruthy();
+      expect(agent.instructionsFormat).toMatch(/^(markdown|plain)$/);
+    });
+  });
+});

package/test/server/mcp-server.test.ts

@@ -5,9 +5,9 @@
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { createMcpServer } from '../../src/server/mcp-server.js';
+import { tmpdir, homedir } from 'os';
+import { join, resolve } from 'path';
+import { createMcpServer, resolveStoragePath } from '../../src/server/mcp-server.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import {
   TOOL_DEFINITIONS,
@@ -166,4 +166,46 @@ describe('McpServer (SDK)', () => {
       expect(validInput.category).toBe('general');
     });
   });
+
+  describe('resolveStoragePath', () => {
+    const originalEnv = process.env.MEMHUB_STORAGE_PATH;
+    const originalCwd = process.cwd.bind(process);
+
+    afterEach(() => {
+      if (originalEnv === undefined) {
+        delete process.env.MEMHUB_STORAGE_PATH;
+      } else {
+        process.env.MEMHUB_STORAGE_PATH = originalEnv;
+      }
+      process.cwd = originalCwd;
+    });
+
+    it('should return ~/.memhub by default', () => {
+      delete process.env.MEMHUB_STORAGE_PATH;
+      const expectedPath = join(homedir(), '.memhub');
+      expect(resolveStoragePath()).toBe(expectedPath);
+    });
+
+    it('should use absolute path from MEMHUB_STORAGE_PATH', () => {
+      const absolutePath = process.platform === 'win32' ? 'C:\\custom\\path' : '/custom/path';
+      process.env.MEMHUB_STORAGE_PATH = absolutePath;
+      expect(resolveStoragePath()).toBe(absolutePath);
+    });
+
+    it('should resolve relative path from cwd', () => {
+      const cwd = process.platform === 'win32' ? 'C:\\project' : '/project';
+      process.cwd = () => cwd;
+      process.env.MEMHUB_STORAGE_PATH = '.memhub';
+      expect(resolveStoragePath()).toBe(resolve(cwd, '.memhub'));
+    });
+
+    it('should resolve .memhub relative path', () => {
+      const cwd = process.platform === 'win32' ? 'C:\\myproject' : '/myproject';
+      process.cwd = () => cwd;
+      process.env.MEMHUB_STORAGE_PATH = '.memhub';
+      const expected =
+        process.platform === 'win32' ? 'C:\\myproject\\.memhub' : '/myproject/.memhub';
+      expect(resolveStoragePath()).toBe(expected);
+    });
+  });
 });