kiku-agent 1.0.7 → 1.0.9

package/server/agent/mcpClient.js

@@ -11,11 +11,53 @@ export class McpClientManager {
   constructor(options = {}) {
     this.clientInfo = options.clientInfo || { name: 'kiku-agent', version: PACKAGE_VERSION };
     this.autoLoad = options.autoLoad !== false;
+    this.globalConfigPath = options.globalConfigPath || path.join(KIKU_DATA_DIR, 'mcp_servers.json');
+    this.configPaths = options.configPaths || [
+      this.globalConfigPath,
+      path.join(process.cwd(), 'opencode.json'),
+      path.join(process.cwd(), '.mcp.json'),
+      path.join(process.cwd(), 'mcp.json'),
+    ];
     this.servers = new Map();
     this.persistedConfigs = new Map();
+    this.configSources = new Map();
     this.toolRegistry = new Map();
   }
 
+  _trackConfigSource(serverName, filePath) {
+    const name = String(serverName || '').trim();
+    if (!name || !filePath) return;
+    const resolvedPath = path.resolve(filePath);
+    const sources = this.configSources.get(name) || new Set();
+    sources.add(resolvedPath);
+    this.configSources.set(name, sources);
+  }
+
+  async _removeFromConfigFile(filePath, serverName) {
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch (error) {
+      if (error?.code === 'ENOENT') return false;
+      throw error;
+    }
+
+    const parsed = JSON.parse(content);
+    let changed = false;
+    for (const key of ['mcpServers', 'mcp']) {
+      const servers = parsed[key];
+      if (servers && typeof servers === 'object' && Object.hasOwn(servers, serverName)) {
+        delete servers[serverName];
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      await fs.writeFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+    }
+    return changed;
+  }
+
   async connect(serverName, serverConfig = {}, { persist = true } = {}) {
     const name = String(serverName || '').trim();
     if (!name) throw new Error('Server name is required to connect to MCP.');
@@ -107,7 +149,8 @@ export class McpClientManager {
       this._rebuildToolRegistry();
 
       if (persist) {
-        await this.savePersistedConfig().catch(() => {});
+        const saveResult = await this.savePersistedConfig().catch(() => null);
+        if (saveResult?.success) this._trackConfigSource(name, saveResult.filePath);
       }
 
       return {
@@ -153,12 +196,25 @@ export class McpClientManager {
   }
 
   async remove(serverName, { persist = true } = {}) {
+    const wasConnected = this.servers.has(serverName);
     await this.disconnect(serverName, { persist: false });
     const hadPersisted = this.persistedConfigs.delete(serverName);
+    const sources = [...(this.configSources.get(serverName) || [])];
+    let removedFromSource = false;
+
     if (persist) {
-      await this.savePersistedConfig().catch(() => {});
+      for (const sourcePath of sources) {
+        const removed = await this._removeFromConfigFile(sourcePath, serverName);
+        removedFromSource = removedFromSource || removed;
+      }
+
+      const saveResult = await this.savePersistedConfig();
+      if (!saveResult.success) {
+        throw new Error(`Failed to update global MCP configuration: ${saveResult.error}`);
+      }
     }
-    return hadPersisted;
+    this.configSources.delete(serverName);
+    return wasConnected || hadPersisted || removedFromSource;
   }
 
   async disconnectAll() {
@@ -325,6 +381,7 @@ export class McpClientManager {
         resourcesCount: server.resources.length,
         promptsCount: server.prompts.length,
         connectedAt: server.connectedAt,
+        sources: [...(this.configSources.get(name) || [])],
         config: server.config,
       });
     }
@@ -339,6 +396,7 @@ export class McpClientManager {
         resourcesCount: 0,
         promptsCount: 0,
         error: cfg.lastError || null,
+        sources: [...(this.configSources.get(name) || [])],
         config: cfg,
       });
     }
@@ -353,7 +411,7 @@ export class McpClientManager {
 
   async savePersistedConfig(customPath) {
     try {
-      const filePath = customPath || path.join(KIKU_DATA_DIR, 'mcp_servers.json');
+      const filePath = customPath || this.globalConfigPath;
       await fs.mkdir(path.dirname(filePath), { recursive: true });
 
       const serversObj = {};
@@ -369,6 +427,9 @@ export class McpClientManager {
       }
 
       await fs.writeFile(filePath, JSON.stringify({ mcpServers: serversObj }, null, 2), 'utf8');
+      for (const name of Object.keys(serversObj)) {
+        this._trackConfigSource(name, filePath);
+      }
       return { success: true, filePath, count: Object.keys(serversObj).length };
     } catch (err) {
       return { success: false, error: err.message };
@@ -383,20 +444,15 @@ export class McpClientManager {
   async loadPersistedServers() {
     if (this.autoLoad === false) return [];
     const results = [];
-    const candidates = [
-      path.join(KIKU_DATA_DIR, 'mcp_servers.json'),
-      path.join(process.cwd(), 'opencode.json'),
-      path.join(process.cwd(), '.mcp.json'),
-      path.join(process.cwd(), 'mcp.json'),
-    ];
 
-    for (const filePath of candidates) {
+    for (const filePath of this.configPaths) {
       try {
         const content = await fs.readFile(filePath, 'utf8');
         const parsed = JSON.parse(content);
         const serversObj = parsed.mcpServers || parsed.mcp || {};
         for (const [name, cfg] of Object.entries(serversObj)) {
           this.persistedConfigs.set(name, cfg);
+          this._trackConfigSource(name, filePath);
           if (cfg.enabled === false || cfg.disabled === true) continue;
           if (this.servers.has(name)) continue;
           try {
@@ -422,6 +478,7 @@ export class McpClientManager {
 
     for (const [name, cfg] of Object.entries(serversObj)) {
       this.persistedConfigs.set(name, cfg);
+      this._trackConfigSource(name, resolvedPath);
       if (cfg.enabled === false || cfg.disabled === true) continue;
       try {
         const res = await this.connect(name, cfg);

package/server/agent/memory.js

@@ -13,9 +13,10 @@ export class AgentMemory {
     this.preferences = {
       language: null,          
       topicsOfInterest: [],    
-      responseStyle: 'default', 
-      userSkills: [],
-      skillsEnabled: true,
+      responseStyle: 'default', 
+      userSkills: [],
+      skillsEnabled: true,
+      favorites: [],
     };
     this.sessions = [];         
     this.summaries = [];       
@@ -68,9 +69,10 @@ export class AgentMemory {
       const loadedPrefs = parsed.preferences || {};
       this.preferences = {
         ...this.preferences,
-        ...loadedPrefs,
-        userSkills: Array.isArray(loadedPrefs.userSkills) ? loadedPrefs.userSkills : [],
-        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
+        ...loadedPrefs,
+        userSkills: Array.isArray(loadedPrefs.userSkills) ? loadedPrefs.userSkills : [],
+        favorites: Array.isArray(loadedPrefs.favorites) ? loadedPrefs.favorites : [],
+        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
           ...t,
           lastSeen: t.lastSeen ? new Date(t.lastSeen) : new Date()
         }))
@@ -238,10 +240,78 @@ export class AgentMemory {
     return grouped;
   }
 
-  setPreference(key, value) {
-    this.preferences[key] = value;
-    this.save().catch(() => {});
-  }
+  setPreference(key, value) {
+    this.preferences[key] = value;
+    this.save().catch(() => {});
+  }
+
+  addFavorite(entity = {}) {
+    const allowedTypes = ['work', 'song', 'role', 'brand', 'award', 'photo', 'stage'];
+    const type = String(entity.type || '').toLowerCase();
+    const title = String(entity.title || '').replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 200);
+    const entityId = String(entity.entityId || title).replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 200);
+    if (!allowedTypes.includes(type)) throw new Error(`Favorite type must be one of: ${allowedTypes.join(', ')}.`);
+    if (!title || !entityId) throw new Error('Favorite title and entity ID are required.');
+    if (!Array.isArray(this.preferences.favorites)) this.preferences.favorites = [];
+    const duplicate = this.preferences.favorites.find(item => item.type === type && item.entityId.toLowerCase() === entityId.toLowerCase());
+    if (duplicate) return { favorite: duplicate, created: false };
+    const favorite = {
+      id: `fav_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+      type,
+      entityId,
+      title,
+      year: Number.isInteger(Number(entity.year)) ? Number(entity.year) : null,
+      detail: String(entity.detail || '').replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 300),
+      url: /^https?:\/\//i.test(String(entity.url || '')) ? String(entity.url).slice(0, 1000) : null,
+      createdAt: new Date().toISOString(),
+    };
+    this.preferences.favorites.unshift(favorite);
+    this.preferences.favorites = this.preferences.favorites.slice(0, 200);
+    this.save().catch(() => {});
+    return { favorite, created: true };
+  }
+
+  getFavorites(type) {
+    const favorites = Array.isArray(this.preferences.favorites) ? this.preferences.favorites : [];
+    if (!type || type === 'all') return [...favorites];
+    return favorites.filter(item => item.type === String(type).toLowerCase());
+  }
+
+  removeFavorite(id) {
+    if (!/^fav_[a-zA-Z0-9_]+$/.test(String(id || ''))) return false;
+    const favorites = Array.isArray(this.preferences.favorites) ? this.preferences.favorites : [];
+    const before = favorites.length;
+    this.preferences.favorites = favorites.filter(item => item.id !== id);
+    if (this.preferences.favorites.length === before) return false;
+    this.save().catch(() => {});
+    return true;
+  }
+
+  async exportFavorites(format = 'json') {
+    const normalized = String(format || 'json').toLowerCase();
+    if (!['json', 'markdown'].includes(normalized)) throw new Error('Favorite export format must be json or markdown.');
+    await fs.mkdir(EXPORT_DIR, { recursive: true });
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const extension = normalized === 'markdown' ? 'md' : 'json';
+    const filename = `kiku-favorites-${timestamp}.${extension}`;
+    const filePath = path.join(EXPORT_DIR, filename);
+    const favorites = this.getFavorites();
+    const content = normalized === 'json'
+      ? JSON.stringify({ exportedAt: now.toISOString(), count: favorites.length, favorites }, null, 2)
+      : [
+          '# Kiku Agent Favorites',
+          '',
+          `Exported: ${now.toISOString()}`,
+          '',
+          '| ID | Type | Title | Year | Detail |',
+          '|---|---|---|---:|---|',
+          ...favorites.map(item => `| ${item.id} | ${item.type} | ${String(item.title).replace(/\|/g, '\\|')} | ${item.year || ''} | ${String(item.detail || '').replace(/\|/g, '\\|')} |`),
+          '',
+        ].join('\n');
+    await fs.writeFile(filePath, content, 'utf-8');
+    return { filePath, filename, count: favorites.length, size: (await fs.stat(filePath)).size };
+  }
 
   addUserSkill(instruction) {
     const value = String(instruction || '').replace(/\s+/g, ' ').trim();
@@ -633,10 +703,13 @@ export class AgentMemory {
 
   async clearAll() {
     this.facts = [];
-    this.preferences = {
-      language: null,
-      topicsOfInterest: [],
-      responseStyle: 'default'
+    this.preferences = {
+      language: null,
+      topicsOfInterest: [],
+      responseStyle: 'default',
+      userSkills: [],
+      skillsEnabled: true,
+      favorites: [],
     };
     this.sessions = [];
     this.summaries = [];