nexus-mcp-agent 0.1.2

package/src/tools/filesystem/index.ts

@@ -0,0 +1,303 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import { readFile, writeFile, readdir, stat, unlink, mkdir, copyFile, rename } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger, logAudit } from '../../core/logger.js';
+import { nexusConfig } from '../../core/config.js';
+
+const log = createContextLogger('tools/filesystem');
+
+function isPathAllowed(path: string): boolean {
+  const absPath = resolve(path);
+  const allowed = nexusConfig.security.allowedDirs.map(d => resolve(d));
+  if (allowed.length === 0) return true;
+  return allowed.some(dir => absPath.startsWith(dir));
+}
+
+function ensureAllowed(path: string): void {
+  if (!isPathAllowed(path)) {
+    throw new Error(`Access denied: ${path} is outside allowed directories`);
+  }
+}
+
+const FsReadSchema = z.object({
+  path: z.string().describe('Path to read'),
+  encoding: z.string().optional().default('utf-8'),
+});
+
+const FsWriteSchema = z.object({
+  path: z.string().describe('File path'),
+  content: z.string().describe('Content to write'),
+  mode: z.enum(['overwrite', 'append']).optional().default('overwrite'),
+});
+
+const FsListSchema = z.object({
+  path: z.string().describe('Directory path'),
+  recursive: z.boolean().optional().default(false),
+});
+
+const FsDeleteSchema = z.object({
+  path: z.string().describe('File path'),
+});
+
+const FsMoveSchema = z.object({
+  source: z.string(),
+  destination: z.string(),
+});
+
+const FsCopySchema = z.object({
+  source: z.string(),
+  destination: z.string(),
+});
+
+const FsSearchSchema = z.object({
+  pattern: z.string().describe('Regex pattern'),
+  path: z.string().optional().default('.'),
+  maxResults: z.number().optional().default(50),
+});
+
+type FsReadParams = z.infer<typeof FsReadSchema>;
+type FsWriteParams = z.infer<typeof FsWriteSchema>;
+type FsListParams = z.infer<typeof FsListSchema>;
+type FsDeleteParams = z.infer<typeof FsDeleteSchema>;
+type FsMoveParams = z.infer<typeof FsMoveSchema>;
+type FsCopyParams = z.infer<typeof FsCopySchema>;
+type FsSearchParams = z.infer<typeof FsSearchSchema>;
+
+async function fsRead(params: FsReadParams): Promise<any> {
+  const { path, encoding = 'utf-8' } = params;
+  ensureAllowed(path);
+  log.info(`Reading: ${path}`);
+
+  try {
+    const stats = await stat(path);
+
+    if (stats.isDirectory()) {
+      const files = await readdir(path);
+      return { type: 'directory', path, files };
+    } else {
+      const content = await readFile(path, encoding as any);
+      return { type: 'file', path, size: stats.size, content };
+    }
+  } catch (error: any) {
+    return { error: error.message };
+  }
+}
+
+async function fsWrite(params: FsWriteParams): Promise<any> {
+  const { path, content, mode = 'overwrite' } = params;
+  ensureAllowed(path);
+  logAudit('fs_write', { path, mode, size: content.length });
+
+  try {
+    const dir = resolve(path, '..');
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+
+    if (mode === 'append') {
+      const existing = existsSync(path) ? await readFile(path, 'utf-8') : '';
+      await writeFile(path, existing + content, 'utf-8');
+    } else {
+      await writeFile(path, content, 'utf-8');
+    }
+
+    return { success: true, path, size: content.length };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function fsList(params: FsListParams): Promise<any> {
+  const { path, recursive = false } = params;
+  ensureAllowed(path);
+
+  try {
+    const listDir = async (dir: string, depth = 0): Promise<any[]> => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      const results: any[] = [];
+
+      for (const entry of entries) {
+        const fullPath = resolve(dir, entry.name);
+        const relPath = path;
+
+        if (entry.isDirectory()) {
+          results.push({ type: 'directory', name: entry.name, path: relPath });
+          if (recursive && depth < 5) {
+            const children = await listDir(fullPath, depth + 1);
+            results.push(...children);
+          }
+        } else {
+          const stats = await stat(fullPath);
+          results.push({ type: 'file', name: entry.name, path: relPath, size: stats.size });
+        }
+      }
+
+      return results;
+    };
+
+    const items = await listDir(path);
+    return { success: true, path, count: items.length, items };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function fsDelete(params: FsDeleteParams): Promise<any> {
+  const { path } = params;
+  ensureAllowed(path);
+  logAudit('fs_delete', { path });
+
+  try {
+    if (!existsSync(path)) {
+      return { success: false, error: 'File does not exist' };
+    }
+
+    const stats = await stat(path);
+    if (stats.isDirectory()) {
+      return { success: false, error: 'Cannot delete directories with fs_delete (safety)' };
+    }
+
+    await unlink(path);
+    return { success: true, path };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function fsMove(params: FsMoveParams): Promise<any> {
+  const { source, destination } = params;
+  ensureAllowed(source);
+  ensureAllowed(destination);
+  logAudit('fs_move', { source, destination });
+
+  try {
+    await rename(source, destination);
+    return { success: true, source, destination };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function fsCopy(params: FsCopyParams): Promise<any> {
+  const { source, destination } = params;
+  ensureAllowed(source);
+  ensureAllowed(destination);
+
+  try {
+    await copyFile(source, destination);
+    return { success: true, source, destination };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function fsSearch(params: FsSearchParams): Promise<any> {
+  const { pattern, path = '.', maxResults = 50 } = params;
+  ensureAllowed(path);
+  log.info(`Searching files for: "${pattern}"`);
+
+  try {
+    const results: any[] = [];
+    const regex = new RegExp(pattern, 'gi');
+
+    const searchFile = async (filePath: string) => {
+      try {
+        const content = await readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+
+        lines.forEach((line, idx) => {
+          if (regex.test(line)) {
+            results.push({ file: filePath, line: idx + 1, content: line.trim() });
+          }
+          regex.lastIndex = 0;
+        });
+      } catch {
+      }
+    };
+
+    const searchDir = async (dir: string) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (results.length >= maxResults) return;
+        const fullPath = resolve(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          if (!['node_modules', '.git', 'dist', 'build'].includes(entry.name)) {
+            await searchDir(fullPath);
+          }
+        } else {
+          await searchFile(fullPath);
+        }
+      }
+    };
+
+    await searchDir(path);
+    return { success: true, pattern, count: results.length, results };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export function registerFilesystemTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('fs_read', {
+    description: 'Read file or directory',
+    inputSchema: FsReadSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsRead(params), null, 2) }],
+  }));
+
+  server.registerTool('fs_write', {
+    description: 'Write content to file',
+    inputSchema: FsWriteSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsWrite(params), null, 2) }],
+  }));
+
+  server.registerTool('fs_list', {
+    description: 'List directory contents',
+    inputSchema: FsListSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsList(params), null, 2) }],
+  }));
+
+  server.registerTool('fs_delete', {
+    description: 'Delete a file',
+    inputSchema: FsDeleteSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsDelete(params), null, 2) }],
+  }));
+
+  server.registerTool('fs_move', {
+    description: 'Move/rename file',
+    inputSchema: FsMoveSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsMove(params), null, 2) }],
+  }));
+
+  server.registerTool('fs_copy', {
+    description: 'Copy file',
+    inputSchema: FsCopySchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsCopy(params), null, 2) }],
+  }));
+
+  server.registerTool('fs_search', {
+    description: 'Search file contents',
+    inputSchema: FsSearchSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await fsSearch(params), null, 2) }],
+  }));
+
+  registry.register({ name: 'fs_read', category: 'filesystem', description: 'Read file/dir', handler: fsRead });
+  registry.register({ name: 'fs_write', category: 'filesystem', description: 'Write file', handler: fsWrite });
+  registry.register({ name: 'fs_list', category: 'filesystem', description: 'List directory', handler: fsList });
+  registry.register({ name: 'fs_delete', category: 'filesystem', description: 'Delete file', handler: fsDelete });
+  registry.register({ name: 'fs_move', category: 'filesystem', description: 'Move file', handler: fsMove });
+  registry.register({ name: 'fs_copy', category: 'filesystem', description: 'Copy file', handler: fsCopy });
+  registry.register({ name: 'fs_search', category: 'filesystem', description: 'Search content', handler: fsSearch });
+
+  log.info('Registered 7 filesystem tools');
+}

package/src/tools/git/index.ts

@@ -0,0 +1,201 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import simpleGit, { SimpleGit } from 'simple-git';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger, logAudit } from '../../core/logger.js';
+
+const log = createContextLogger('tools/git');
+
+function getGit(cwd?: string): SimpleGit {
+  return simpleGit(cwd || process.cwd());
+}
+
+const GitCwdSchema = z.object({
+  cwd: z.string().optional(),
+});
+
+const GitDiffSchema = z.object({
+  cwd: z.string().optional(),
+  staged: z.boolean().optional().default(false),
+});
+
+const GitLogSchema = z.object({
+  cwd: z.string().optional(),
+  maxCount: z.number().optional().default(20),
+});
+
+const GitCommitSchema = z.object({
+  message: z.string(),
+  cwd: z.string().optional(),
+  all: z.boolean().optional().default(false),
+});
+
+const GitPushSchema = z.object({
+  cwd: z.string().optional(),
+  remote: z.string().optional(),
+  branch: z.string().optional(),
+});
+
+const GitPullSchema = z.object({
+  cwd: z.string().optional(),
+  remote: z.string().optional(),
+  branch: z.string().optional(),
+});
+
+const GitBranchSchema = z.object({
+  cwd: z.string().optional(),
+  name: z.string().optional(),
+  checkout: z.boolean().optional().default(false),
+});
+
+type GitCwdParams = z.infer<typeof GitCwdSchema>;
+type GitDiffParams = z.infer<typeof GitDiffSchema>;
+type GitLogParams = z.infer<typeof GitLogSchema>;
+type GitCommitParams = z.infer<typeof GitCommitSchema>;
+type GitPushParams = z.infer<typeof GitPushSchema>;
+type GitPullParams = z.infer<typeof GitPullSchema>;
+type GitBranchParams = z.infer<typeof GitBranchSchema>;
+
+async function gitStatus(params: GitCwdParams): Promise<any> {
+  try {
+    const git = getGit(params.cwd);
+    const status = await git.status();
+    return { success: true, ...status };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function gitDiff(params: GitDiffParams): Promise<any> {
+  try {
+    const git = getGit(params.cwd);
+    const diff = params.staged ? await git.diff(['--staged']) : await git.diff();
+    return { success: true, diff };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function gitLog(params: GitLogParams): Promise<any> {
+  try {
+    const git = getGit(params.cwd);
+    const log_ = await git.log({ maxCount: params.maxCount || 20 });
+    return { success: true, commits: log_.all };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function gitCommit(params: GitCommitParams): Promise<any> {
+  logAudit('git_commit', { message: params.message, cwd: params.cwd });
+  try {
+    const git = getGit(params.cwd);
+    if (params.all) await git.add('.');
+    const result = await git.commit(params.message);
+    return { success: true, ...result };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function gitPush(params: GitPushParams): Promise<any> {
+  logAudit('git_push', { cwd: params.cwd });
+  try {
+    const git = getGit(params.cwd);
+    const result = await git.push(params.remote || 'origin', params.branch);
+    return { success: true, ...result };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function gitPull(params: GitPullParams): Promise<any> {
+  try {
+    const git = getGit(params.cwd);
+    const result = await git.pull(params.remote || 'origin', params.branch);
+    return { success: true, ...result };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function gitBranch(params: GitBranchParams): Promise<any> {
+  try {
+    const git = getGit(params.cwd);
+    if (params.name) {
+      if (params.checkout) {
+        await git.checkoutLocalBranch(params.name);
+        return { success: true, message: `Created and checked out ${params.name}` };
+      } else {
+        await git.branch([params.name]);
+        return { success: true, message: `Created branch ${params.name}` };
+      }
+    } else {
+      const branches = await git.branch();
+      return { success: true, ...branches };
+    }
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+export function registerGitTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('git_status', {
+    description: 'Get git status',
+    inputSchema: GitCwdSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitStatus(params), null, 2) }],
+  }));
+
+  server.registerTool('git_diff', {
+    description: 'Get git diff',
+    inputSchema: GitDiffSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitDiff(params), null, 2) }],
+  }));
+
+  server.registerTool('git_log', {
+    description: 'Get git log',
+    inputSchema: GitLogSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitLog(params), null, 2) }],
+  }));
+
+  server.registerTool('git_commit', {
+    description: 'Create git commit',
+    inputSchema: GitCommitSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitCommit(params), null, 2) }],
+  }));
+
+  server.registerTool('git_push', {
+    description: 'Push to remote',
+    inputSchema: GitPushSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitPush(params), null, 2) }],
+  }));
+
+  server.registerTool('git_pull', {
+    description: 'Pull from remote',
+    inputSchema: GitPullSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitPull(params), null, 2) }],
+  }));
+
+  server.registerTool('git_branch', {
+    description: 'Create/list branches',
+    inputSchema: GitBranchSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await gitBranch(params), null, 2) }],
+  }));
+
+  registry.register({ name: 'git_status', category: 'git', description: 'Git status', handler: gitStatus });
+  registry.register({ name: 'git_diff', category: 'git', description: 'Git diff', handler: gitDiff });
+  registry.register({ name: 'git_log', category: 'git', description: 'Git log', handler: gitLog });
+  registry.register({ name: 'git_commit', category: 'git', description: 'Git commit', handler: gitCommit });
+  registry.register({ name: 'git_push', category: 'git', description: 'Git push', handler: gitPush });
+  registry.register({ name: 'git_pull', category: 'git', description: 'Git pull', handler: gitPull });
+  registry.register({ name: 'git_branch', category: 'git', description: 'Git branch', handler: gitBranch });
+
+  log.info('Registered 7 git tools');
+}

package/src/tools/memory/index.ts

@@ -0,0 +1,204 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import { ChromaClient, Collection } from 'chromadb';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger } from '../../core/logger.js';
+import { nexusConfig } from '../../core/config.js';
+import { v4 as uuid } from 'uuid';
+
+const log = createContextLogger('tools/memory');
+
+let chromaClient: ChromaClient | null = null;
+let collection: Collection | null = null;
+
+async function getCollection(): Promise<Collection> {
+  if (collection) return collection;
+
+  try {
+    chromaClient = new ChromaClient({ path: nexusConfig.vector.chromaUrl });
+    collection = await chromaClient.getOrCreateCollection({
+      name: nexusConfig.vector.collection,
+      metadata: { description: 'NEXUS long-term memory' },
+    });
+    return collection;
+  } catch (error: any) {
+    log.warn(`ChromaDB not available: ${error.message}. Using in-memory fallback.`);
+    throw error;
+  }
+}
+
+const memoryFallback: Map<string, { content: string; metadata: any; timestamp: number }> = new Map();
+
+const MemoryStoreSchema = z.object({
+  content: z.string().describe('Content to remember'),
+  metadata: z.record(z.any()).optional().describe('Additional metadata'),
+  tags: z.array(z.string()).optional().describe('Tags for categorization'),
+});
+
+const MemorySearchSchema = z.object({
+  query: z.string().describe('Search query'),
+  limit: z.number().optional().default(10),
+  tags: z.array(z.string()).optional(),
+});
+
+const MemoryGetSchema = z.object({
+  id: z.string(),
+});
+
+const MemoryForgetSchema = z.object({
+  id: z.string(),
+});
+
+const MemoryListSchema = z.object({
+  limit: z.number().optional().default(50),
+});
+
+type MemoryStoreParams = z.infer<typeof MemoryStoreSchema>;
+type MemorySearchParams = z.infer<typeof MemorySearchSchema>;
+type MemoryGetParams = z.infer<typeof MemoryGetSchema>;
+type MemoryForgetParams = z.infer<typeof MemoryForgetSchema>;
+type MemoryListParams = z.infer<typeof MemoryListSchema>;
+
+async function memoryStore(params: MemoryStoreParams): Promise<any> {
+  const { content, metadata = {}, tags = [] } = params;
+  const id = uuid();
+  const timestamp = Date.now();
+
+  log.info(`Storing memory: ${id} (${content.length} chars)`);
+
+  try {
+    const col = await getCollection();
+    await col.add({
+      ids: [id],
+      documents: [content],
+      metadatas: [{ ...metadata, tags: tags.join(','), timestamp }],
+    });
+    return { success: true, id, stored: 'chromadb' };
+  } catch (error) {
+    memoryFallback.set(id, { content, metadata: { ...metadata, tags }, timestamp });
+    log.warn(`Stored in memory fallback: ${id}`);
+    return { success: true, id, stored: 'memory-fallback', warning: 'ChromaDB unavailable' };
+  }
+}
+
+async function memorySearch(params: MemorySearchParams): Promise<any> {
+  const { query, limit = 10, tags = [] } = params;
+
+  log.info(`Searching memory: "${query}"`);
+
+  try {
+    const col = await getCollection();
+    const results = await col.query({
+      queryTexts: [query],
+      nResults: limit,
+      where: tags.length > 0 ? { tags: { $contains: tags.join(',') } as any } : undefined,
+    });
+
+    const memories = (results.documents[0] || []).map((doc, i) => ({
+      id: results.ids[0][i],
+      content: doc,
+      metadata: results.metadatas?.[0]?.[i],
+      distance: results.distances?.[0]?.[i],
+    }));
+
+    return { success: true, count: memories.length, results: memories };
+  } catch (error) {
+    const results = Array.from(memoryFallback.entries())
+      .filter(([_, m]) => m.content.toLowerCase().includes(query.toLowerCase()))
+      .slice(0, limit)
+      .map(([id, m]) => ({ id, ...m }));
+    return { success: true, count: results.length, results, source: 'memory-fallback' };
+  }
+}
+
+async function memoryGet(params: MemoryGetParams): Promise<any> {
+  try {
+    const col = await getCollection();
+    const result = await col.get({ ids: [params.id] });
+    if (result.documents.length === 0) return { success: false, error: 'Not found' };
+    return { success: true, id: params.id, content: result.documents[0], metadata: result.metadatas?.[0] };
+  } catch (error) {
+    const mem = memoryFallback.get(params.id);
+    if (!mem) return { success: false, error: 'Not found' };
+    return { success: true, id: params.id, ...mem, source: 'memory-fallback' };
+  }
+}
+
+async function memoryForget(params: MemoryForgetParams): Promise<any> {
+  log.info(`Forgetting memory: ${params.id}`);
+  try {
+    const col = await getCollection();
+    await col.delete({ ids: [params.id] });
+    return { success: true };
+  } catch (error) {
+    memoryFallback.delete(params.id);
+    return { success: true, source: 'memory-fallback' };
+  }
+}
+
+async function memoryList(params: MemoryListParams): Promise<any> {
+  const limit = params.limit || 50;
+  try {
+    const col = await getCollection();
+    const result = await col.get({ limit });
+    return {
+      success: true,
+      count: result.ids.length,
+      memories: result.ids.map((id, i) => ({
+        id,
+        preview: (result.documents[i] || '').slice(0, 200),
+        metadata: result.metadatas?.[i],
+      })),
+    };
+  } catch (error) {
+    const memories = Array.from(memoryFallback.entries()).slice(0, limit).map(([id, m]) => ({
+      id, preview: m.content.slice(0, 200), metadata: m.metadata,
+    }));
+    return { success: true, count: memories.length, memories, source: 'memory-fallback' };
+  }
+}
+
+export function registerMemoryTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('memory_store', {
+    description: 'Store information in long-term memory',
+    inputSchema: MemoryStoreSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await memoryStore(params), null, 2) }],
+  }));
+
+  server.registerTool('memory_search', {
+    description: 'Search long-term memory',
+    inputSchema: MemorySearchSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await memorySearch(params), null, 2) }],
+  }));
+
+  server.registerTool('memory_get', {
+    description: 'Get specific memory by ID',
+    inputSchema: MemoryGetSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await memoryGet(params), null, 2) }],
+  }));
+
+  server.registerTool('memory_forget', {
+    description: 'Delete a memory',
+    inputSchema: MemoryForgetSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await memoryForget(params), null, 2) }],
+  }));
+
+  server.registerTool('memory_list', {
+    description: 'List recent memories',
+    inputSchema: MemoryListSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await memoryList(params), null, 2) }],
+  }));
+
+  registry.register({ name: 'memory_store', category: 'memory', description: 'Store memory', handler: memoryStore });
+  registry.register({ name: 'memory_search', category: 'memory', description: 'Search memory', handler: memorySearch });
+  registry.register({ name: 'memory_get', category: 'memory', description: 'Get memory', handler: memoryGet });
+  registry.register({ name: 'memory_forget', category: 'memory', description: 'Forget memory', handler: memoryForget });
+  registry.register({ name: 'memory_list', category: 'memory', description: 'List memories', handler: memoryList });
+
+  log.info('Registered 5 memory tools');
+}