@hanhnd/agent-kit 1.0.34 → 1.0.35

package/dist/core/config/index.d.ts

@@ -24,6 +24,9 @@ export { MemoryConfig };
 export declare function resolveMemoryConfig(settings: ProjectSettings, workspaceRoot: string): MemoryConfig;
 export declare function loadProjectSettings(projectDir: string): ProjectSettings;
 export declare function writeProjectSettings(workspaceRoot: string, patch: Partial<ProjectSettings>): void;
+export declare function getGlobalSettingsFile(): string;
+export declare function loadGlobalSettings(): ProjectSettings;
+export declare function writeGlobalSettings(patch: Partial<ProjectSettings>): void;
 export declare function resolveConversationDigestConfig(settings: ProjectSettings): ConversationDigestSettings | undefined;
 /**
  * Sensitive files that agents are FORBIDDEN from reading/writing.

package/dist/core/config/index.js

@@ -3,6 +3,7 @@
  * Shared configuration constants and loaders
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { DEFAULT_MEMORY_CONFIG } from '../../services/memory/constants.js';
 import { atomicWriteJsonFile } from '../../utils/files.js';
@@ -65,6 +66,25 @@ export function writeProjectSettings(workspaceRoot, patch) {
     const current = loadProjectSettings(workspaceRoot);
     atomicWriteJsonFile(settingsPath, { ...current, ...patch });
 }
+export function getGlobalSettingsFile() {
+    return path.join(os.homedir(), '.agent-kit', 'settings.json');
+}
+export function loadGlobalSettings() {
+    const file = getGlobalSettingsFile();
+    if (fs.existsSync(file)) {
+        try {
+            return JSON.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch (error) {
+            console.error(`[agent-kit] Warning: Failed to parse ${file}:`, error);
+        }
+    }
+    return {};
+}
+export function writeGlobalSettings(patch) {
+    const current = loadGlobalSettings();
+    atomicWriteJsonFile(getGlobalSettingsFile(), { ...current, ...patch });
+}
 export function resolveConversationDigestConfig(settings) {
     const digest = settings.memory?.conversationDigest;
     if (!digest?.initialized || typeof digest.modelId !== 'string' || typeof digest.initializedAt !== 'string') {

package/dist/entrypoints/server.js

@@ -10,7 +10,6 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { registerCoreTools } from '../mcp/core.js';
 import { registerAgentTools } from '../mcp/agent.js';
 import { registerIntegrationTools } from '../mcp/integration.js';
-import { loadProjectSettings } from '../core/config/index.js';
 import { registerMemoryTools } from '../mcp/memory.js';
 import { getWorkspaceRoot } from '../utils/utils.js';
 const server = new McpServer({
@@ -24,8 +23,7 @@ registerIntegrationTools(server);
 registerCoreTools(server);
 registerAgentTools(server);
 const workspaceRoot = getWorkspaceRoot();
-const settings = loadProjectSettings(workspaceRoot);
-const memoryIndexer = registerMemoryTools(server, settings, workspaceRoot);
+const memoryIndexer = registerMemoryTools(server, workspaceRoot);
 // ═══════════════════════════════════════════════════════════════
 // START SERVER
 // ═══════════════════════════════════════════════════════════════

package/dist/mcp/memory.d.ts

@@ -8,8 +8,9 @@ import { type ProjectSettings } from '../core/config/index.js';
  * Returns the MemoryIndexer so the caller can fire startupIndex() after server.connect().
  * Returns null when memory is disabled (settings.memory.enabled !== true).
  */
-export declare function registerMemoryTools(server: McpServer, settings: ProjectSettings, workspaceRoot: string, overrides?: {
+export declare function registerMemoryTools(server: McpServer, workspaceRoot: string, overrides?: {
     indexer?: MemoryIndexer;
     store?: MemoryStore;
     config?: MemoryConfig;
+    settings?: ProjectSettings;
 }): MemoryIndexer | null;

package/dist/mcp/memory.js

@@ -1,31 +1,30 @@
+import * as fs from 'fs';
 import * as path from 'path';
 import { z } from 'zod';
 import { Embedder } from '../services/memory/embedder.js';
 import { MemoryIndexer } from '../services/memory/indexer.js';
 import { MemoryStore } from '../services/memory/store.js';
+import { SOURCE_TYPES } from '../services/memory/types.js';
 import { initializeConversationDigestModel } from '../services/digest/processor.js';
 import { DEFAULT_DIGEST_MODEL_ID } from '../services/digest/constants.js';
-import { mcpJson, mcpText } from '../utils/utils.js';
-import { loadProjectSettings, resolveConversationDigestConfig, resolveMemoryConfig, } from '../core/config/index.js';
+import { formatError, mcpJson, mcpText } from '../utils/utils.js';
+import { loadGlobalSettings, resolveConversationDigestConfig, resolveMemoryConfig, } from '../core/config/index.js';
 /**
  * Registers tool handlers onto an already-constructed indexer/store pair.
  */
 function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoot = process.cwd()) {
-    server.tool('kit_memory_search', 'Search persistent memory for context relevant to the current question. Returns semantically relevant results using hybrid dense+BM25+RRF search.', {
-        query: z.string().min(1).describe('Search query'),
+    server.tool('kit_memory_search', 'Search persistent memory for factual or semantic matches (decisions, concepts, entities). Extract concise keywords only, removing stopwords and filler words from the user request before querying. Use kit_memory_recent for temporal or recency questions.', {
+        query: z.string().min(1).describe('Keyword-only search query with stopwords removed'),
         top_k: z.number().int().positive().optional().describe('Number of results to return'),
     }, async ({ query, top_k }) => {
         try {
             const results = await indexer.search(query, top_k ?? config.topK);
-            if (results.length === 0) {
-                const degradedNote = !store.vecAvailable
-                    ? '⚠️ Vector search unavailable — showing keyword-only results.\n\n'
-                    : '';
-                return mcpText(`${degradedNote}No memories found for query: "${query}"`);
-            }
             const degradedNote = !store.vecAvailable
                 ? '⚠️ Vector search unavailable — showing keyword-only results.\n\n'
                 : '';
+            if (results.length === 0) {
+                return mcpText(`${degradedNote}No memories found for query: "${query}"`);
+            }
             const formatted = results
                 .map((r) => {
                 const displaySource = r.chunk.source.replace(/^compiled\//, '');
@@ -38,8 +37,34 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
             return mcpText(`${degradedNote}${formatted}`);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return mcpText(`kit_memory_search failed: ${message}`);
+            return mcpText(`kit_memory_search failed: ${formatError(err)}`);
+        }
+    });
+    server.tool('kit_memory_recent', 'Return the N most recently updated memory sources. Optionally filter by source type. Use for temporal questions like "what did we do last session" or "recent".', {
+        n: z.number().int().positive().max(50).optional().describe('How many recent sources to return (default 5)'),
+        source_type: z.enum(SOURCE_TYPES).optional().describe('Optional source type filter'),
+    }, async ({ n, source_type }) => {
+        try {
+            const rows = store.getRecentSources({ limit: n ?? 5, sourceType: source_type });
+            if (rows.length === 0)
+                return mcpText('No recent sources found.');
+            const blocks = [];
+            for (const row of rows) {
+                try {
+                    const content = fs.readFileSync(path.join(config.wikiDir, row.source), 'utf8');
+                    const displaySource = row.source.replace(/^compiled\//, '');
+                    blocks.push(`### ${displaySource}\n${content}`);
+                }
+                catch (err) {
+                    console.warn(`[memory] Skipping unavailable recent source ${row.source}:`, err);
+                }
+            }
+            if (blocks.length === 0)
+                return mcpText('No recent sources found.');
+            return mcpText(blocks.join('\n\n---\n\n'));
+        }
+        catch (err) {
+            return mcpText(`kit_memory_recent failed: ${formatError(err)}`);
         }
     });
     server.tool('kit_memory_save', 'Save content to wiki/raw for inclusion after the next /wiki compile.', {
@@ -54,8 +79,10 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
             });
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return mcpJson({ saved: false, error: message });
+            return mcpJson({
+                saved: false,
+                error: formatError(err),
+            });
         }
     });
     server.tool('kit_memory_digest_init', 'Initialize or toggle local conversation digesting. Downloads/cache-loads the pinned local model only when explicitly invoked.', {
@@ -63,7 +90,7 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
         enabled: z.boolean().optional().describe('Enable or disable conversation digesting'),
     }, async ({ model_id, enabled }) => {
         try {
-            const existingConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+            const existingConfig = resolveConversationDigestConfig(loadGlobalSettings());
             const result = await initializeConversationDigestModel({
                 workspaceRoot,
                 modelId: model_id ?? existingConfig?.modelId ?? DEFAULT_DIGEST_MODEL_ID,
@@ -78,8 +105,7 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
             });
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return mcpJson({ initialized: false, error: message });
+            return mcpJson({ initialized: false, error: formatError(err) });
         }
     });
 }
@@ -88,7 +114,8 @@ function registerMemoryToolHandlers(server, indexer, store, config, workspaceRoo
  * Returns the MemoryIndexer so the caller can fire startupIndex() after server.connect().
  * Returns null when memory is disabled (settings.memory.enabled !== true).
  */
-export function registerMemoryTools(server, settings, workspaceRoot, overrides) {
+export function registerMemoryTools(server, workspaceRoot, overrides) {
+    const settings = overrides?.settings ?? loadGlobalSettings();
     if (settings.memory?.enabled !== true)
         return null;
     const config = overrides?.config ?? resolveMemoryConfig(settings, workspaceRoot);