@hanhnd/agent-kit 1.0.34 → 1.0.35

package/dist/services/memory/store.js

@@ -1,7 +1,10 @@
 import Database from 'better-sqlite3';
 import * as fs from 'fs';
+import { createRequire } from 'module';
 import * as path from 'path';
 import { eng, removeStopwords } from 'stopword';
+const require = createRequire(import.meta.url);
+export const SCHEMA_VERSION = 2;
 export class StoreError extends Error {
     constructor(message, cause) {
         super(message);
@@ -46,7 +49,6 @@ export class MemoryStore {
     }
     loadVecExtension(db) {
         try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
             const sqliteVec = require('sqlite-vec');
             sqliteVec.load(db);
             this._vecAvailable = true;
@@ -57,58 +59,79 @@ export class MemoryStore {
         }
     }
     createSchema(db) {
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS memory_chunks (
-        rowid         INTEGER PRIMARY KEY AUTOINCREMENT,
-        id            TEXT NOT NULL UNIQUE,
-        source        TEXT NOT NULL,
-        heading       TEXT NOT NULL DEFAULT '',
-        heading_level INTEGER NOT NULL DEFAULT 0,
-        content       TEXT NOT NULL,
-        line_start    INTEGER NOT NULL,
-        line_end      INTEGER NOT NULL,
-        indexed_at    INTEGER NOT NULL
-      );
-
-      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
-        source,
-        heading,
-        content,
-        content='memory_chunks',
-        content_rowid='rowid'
-      );
-
-      CREATE TRIGGER IF NOT EXISTS memory_chunks_ai
-        AFTER INSERT ON memory_chunks BEGIN
-          INSERT INTO memory_fts(rowid, source, heading, content)
-            VALUES (new.rowid, new.source, new.heading, new.content);
-        END;
-
-      CREATE TRIGGER IF NOT EXISTS memory_chunks_ad
-        AFTER DELETE ON memory_chunks BEGIN
-          INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
-            VALUES ('delete', old.rowid, old.source, old.heading, old.content);
-        END;
-    `);
-        if (this._vecAvailable) {
-            try {
+        try {
+            const current = Number(db.pragma('user_version', { simple: true }) ?? 0);
+            if (current < SCHEMA_VERSION) {
                 db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
-            embedding FLOAT[${this.config.vectorDimension}]
-          );
+          DROP TRIGGER IF EXISTS memory_chunks_ai;
+          DROP TRIGGER IF EXISTS memory_chunks_ad;
+          DROP TABLE IF EXISTS memory_fts;
+          DROP TABLE IF EXISTS memory_vec;
+          DROP TABLE IF EXISTS memory_chunks;
         `);
+                db.pragma(`user_version = ${SCHEMA_VERSION}`);
             }
-            catch (err) {
-                console.warn('[memory-store] Failed to create memory_vec, disabling vector search:', err);
-                this._vecAvailable = false;
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_chunks (
+          rowid         INTEGER PRIMARY KEY AUTOINCREMENT,
+          id            TEXT NOT NULL UNIQUE,
+          source        TEXT NOT NULL,
+          source_type   TEXT NOT NULL DEFAULT 'wiki',
+          heading       TEXT NOT NULL DEFAULT '',
+          heading_level INTEGER NOT NULL DEFAULT 0,
+          content       TEXT NOT NULL,
+          line_start    INTEGER NOT NULL,
+          line_end      INTEGER NOT NULL,
+          indexed_at    INTEGER NOT NULL,
+          file_mtime_at INTEGER NOT NULL DEFAULT 0
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_memory_chunks_type_mtime
+          ON memory_chunks (source_type, file_mtime_at DESC);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+          source,
+          heading,
+          content,
+          content='memory_chunks',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memory_chunks_ai
+          AFTER INSERT ON memory_chunks BEGIN
+            INSERT INTO memory_fts(rowid, source, heading, content)
+              VALUES (new.rowid, new.source, new.heading, new.content);
+          END;
+
+        CREATE TRIGGER IF NOT EXISTS memory_chunks_ad
+          AFTER DELETE ON memory_chunks BEGIN
+            INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
+              VALUES ('delete', old.rowid, old.source, old.heading, old.content);
+          END;
+      `);
+            if (this._vecAvailable) {
+                try {
+                    db.exec(`
+            CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
+              embedding FLOAT[${this.config.vectorDimension}]
+            );
+          `);
+                }
+                catch (err) {
+                    console.warn('[memory-store] Failed to create memory_vec, disabling vector search:', err);
+                    this._vecAvailable = false;
+                }
             }
         }
+        catch (err) {
+            throw new StoreError('schema migration failed', err);
+        }
     }
     upsert(chunks, embeddings) {
         const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
-        (id, source, heading, heading_level, content, line_start, line_end, indexed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         let insertVec = null;
         if (this._vecAvailable) {
@@ -120,9 +143,9 @@ export class MemoryStore {
                 try {
                     // Delete existing row first to get correct rowid
                     this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
-                    const info = insertChunk.run(chunk.id, chunk.source, chunk.heading, chunk.headingLevel, chunk.content, chunk.lineStart, chunk.lineEnd, Date.now());
+                    const info = insertChunk.run(chunk.id, chunk.source, chunk.sourceType, chunk.heading, chunk.headingLevel, chunk.content, chunk.lineStart, chunk.lineEnd, Date.now(), chunk.fileMtimeAt);
                     if (insertVec && embeddings[i] && info.lastInsertRowid) {
-                        const rowid = Number(info.lastInsertRowid);
+                        const rowid = typeof info.lastInsertRowid === 'bigint' ? info.lastInsertRowid : BigInt(info.lastInsertRowid);
                         const emb = embeddings[i];
                         const buf = Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength);
                         insertVec.run(rowid, buf);
@@ -148,6 +171,21 @@ export class MemoryStore {
         const rows = this.db.prepare(`SELECT DISTINCT source FROM memory_chunks`).all();
         return rows.map((r) => r.source);
     }
+    getRecentSources(options) {
+        const limit = Math.min(Math.max(1, options.limit || 5), 50);
+        const whereClause = options.sourceType ? ' WHERE source_type = ?' : '';
+        const params = options.sourceType ? [options.sourceType, limit] : [limit];
+        try {
+            const rows = this.db
+                .prepare(`SELECT source, MAX(file_mtime_at) AS t FROM memory_chunks${whereClause} GROUP BY source ORDER BY t DESC LIMIT ?`)
+                .all(...params);
+            return rows.map((row) => ({ source: row.source, fileMtimeAt: row.t }));
+        }
+        catch (err) {
+            console.warn('[memory-store] Recent source lookup failed:', err);
+            return [];
+        }
+    }
     deleteBySource(source) {
         const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE source = ?`).all(source);
         const deleteAll = this.db.transaction(() => {
@@ -239,17 +277,19 @@ export class MemoryStore {
             return [];
         const placeholders = ids.map(() => '?').join(', ');
         const rows = this.db
-            .prepare(`SELECT id, source, heading, heading_level, content, line_start, line_end
+            .prepare(`SELECT id, source, source_type, heading, heading_level, content, line_start, line_end, file_mtime_at
          FROM memory_chunks WHERE id IN (${placeholders})`)
             .all(...ids);
         return rows.map((r) => ({
             id: r.id,
             source: r.source,
+            sourceType: r.source_type,
             heading: r.heading,
             headingLevel: r.heading_level,
             content: r.content,
             lineStart: r.line_start,
             lineEnd: r.line_end,
+            fileMtimeAt: r.file_mtime_at,
         }));
     }
     get vecAvailable() {

package/dist/services/memory/store.test.js

@@ -2,8 +2,9 @@ import * as assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import Database from 'better-sqlite3';
 import { after, before, describe, test } from 'node:test';
-import { MemoryStore } from './store.js';
+import { MemoryStore, SCHEMA_VERSION } from './store.js';
 import { EmbeddingModelName } from './types.js';
 const TEST_CONFIG = {
     enabled: true,
@@ -11,18 +12,20 @@ const TEST_CONFIG = {
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: EmbeddingModelName.SMALL,
+    embeddingModel: EmbeddingModelName.BASE,
     vectorDimension: 384,
 };
 function makeChunk(overrides = {}) {
     return {
         id: 'test-id-0000001',
         source: 'test.md',
+        sourceType: 'wiki',
         heading: 'Test Heading',
         headingLevel: 1,
         content: 'This is test content for BM25 search.',
         lineStart: 1,
         lineEnd: 5,
+        fileMtimeAt: 1000,
         ...overrides,
     };
 }
@@ -48,11 +51,14 @@ describe('MemoryStore', () => {
         assert.equal(hashes.size, 0);
     });
     test('upsert stores chunks and hashesBySource returns their ids', () => {
-        const chunk = makeChunk({ id: 'upsert-test-0001', source: 'upsert.md' });
+        const chunk = makeChunk({ id: 'upsert-test-0001', source: 'upsert.md', sourceType: 'entity', fileMtimeAt: 2000 });
         const embedding = new Float32Array(384).fill(0.1);
         store.upsert([chunk], [embedding]);
         const hashes = store.hashesBySource('upsert.md');
         assert.ok(hashes.has('upsert-test-0001'));
+        const [stored] = store.getChunksByIds(['upsert-test-0001']);
+        assert.equal(stored.sourceType, 'entity');
+        assert.equal(stored.fileMtimeAt, 2000);
     });
     test('deleteBySource removes all chunks for that source', () => {
         const c1 = makeChunk({
@@ -108,11 +114,13 @@ describe('MemoryStore', () => {
         const chunk = makeChunk({
             id: 'get-by-ids-0001',
             source: 'metadata.md',
+            sourceType: 'concept',
             heading: 'Metadata Section',
             headingLevel: 2,
             content: 'Content for metadata test',
             lineStart: 10,
             lineEnd: 20,
+            fileMtimeAt: 3000,
         });
         store.upsert([chunk], [new Float32Array(384)]);
         const results = store.getChunksByIds(['get-by-ids-0001']);
@@ -120,10 +128,12 @@ describe('MemoryStore', () => {
         const [r] = results;
         assert.equal(r.id, 'get-by-ids-0001');
         assert.equal(r.source, 'metadata.md');
+        assert.equal(r.sourceType, 'concept');
         assert.equal(r.heading, 'Metadata Section');
         assert.equal(r.headingLevel, 2);
         assert.equal(r.lineStart, 10);
         assert.equal(r.lineEnd, 20);
+        assert.equal(r.fileMtimeAt, 3000);
     });
     test('getChunksByIds returns only found rows for mixed ids', () => {
         const chunk = makeChunk({ id: 'partial-found-0001', source: 'partial.md', content: 'partial' });
@@ -162,4 +172,114 @@ describe('MemoryStore', () => {
         const results = store.searchBm25('degradedModeTest', 5);
         assert.ok(results.length > 0, 'FTS5 search must work regardless of vecAvailable');
     });
+    test('getRecentSources returns distinct sources ordered by newest chunk mtime', () => {
+        const recentDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-recent-store-'));
+        const recentStore = new MemoryStore(path.join(recentDir, 'index.db'), { ...TEST_CONFIG, wikiDir: recentDir });
+        try {
+            recentStore.upsert([
+                makeChunk({
+                    id: 'recent-digest-old',
+                    source: 'compiled/provisional/conversation-digests/old.md',
+                    sourceType: 'digest',
+                    fileMtimeAt: 100,
+                    content: 'old digest',
+                }),
+                makeChunk({
+                    id: 'recent-digest-new',
+                    source: 'compiled/provisional/conversation-digests/new.md',
+                    sourceType: 'digest',
+                    fileMtimeAt: 300,
+                    content: 'new digest',
+                }),
+                makeChunk({
+                    id: 'recent-digest-newer-same-source',
+                    source: 'compiled/provisional/conversation-digests/old.md',
+                    sourceType: 'digest',
+                    fileMtimeAt: 400,
+                    content: 'old digest update',
+                }),
+                makeChunk({
+                    id: 'recent-entity',
+                    source: 'compiled/entities/entity.md',
+                    sourceType: 'entity',
+                    fileMtimeAt: 500,
+                    content: 'entity',
+                }),
+            ], [new Float32Array(384), new Float32Array(384), new Float32Array(384), new Float32Array(384)]);
+            const allRows = recentStore.getRecentSources({ limit: 10 });
+            assert.deepEqual(allRows.map((row) => row.source), [
+                'compiled/entities/entity.md',
+                'compiled/provisional/conversation-digests/old.md',
+                'compiled/provisional/conversation-digests/new.md',
+            ]);
+            const digestRows = recentStore.getRecentSources({ limit: 10, sourceType: 'digest' });
+            assert.deepEqual(digestRows.map((row) => row.source), ['compiled/provisional/conversation-digests/old.md', 'compiled/provisional/conversation-digests/new.md']);
+            assert.equal(digestRows[0].fileMtimeAt, 400);
+        }
+        finally {
+            recentStore.close();
+            fs.rmSync(recentDir, { recursive: true, force: true });
+        }
+    });
+    test('schema migration recreates versioned schema with new columns and recency index', () => {
+        const migrationDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-migration-'));
+        const migrationDbPath = path.join(migrationDir, 'index.db');
+        const db = new Database(migrationDbPath);
+        db.exec(`
+      PRAGMA user_version = 1;
+      CREATE TABLE memory_chunks (
+        rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE,
+        source TEXT NOT NULL,
+        heading TEXT NOT NULL DEFAULT '',
+        heading_level INTEGER NOT NULL DEFAULT 0,
+        content TEXT NOT NULL,
+        line_start INTEGER NOT NULL,
+        line_end INTEGER NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+      CREATE VIRTUAL TABLE memory_fts USING fts5(
+        source,
+        heading,
+        content,
+        content='memory_chunks',
+        content_rowid='rowid'
+      );
+      CREATE TRIGGER memory_chunks_ai
+        AFTER INSERT ON memory_chunks BEGIN
+          INSERT INTO memory_fts(rowid, source, heading, content)
+            VALUES (new.rowid, new.source, new.heading, new.content);
+        END;
+      CREATE TRIGGER memory_chunks_ad
+        AFTER DELETE ON memory_chunks BEGIN
+          INSERT INTO memory_fts(memory_fts, rowid, source, heading, content)
+            VALUES ('delete', old.rowid, old.source, old.heading, old.content);
+        END;
+    `);
+        db.prepare(`INSERT INTO memory_chunks
+        (id, source, heading, heading_level, content, line_start, line_end, indexed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run('old-row', 'old.md', '', 0, 'old content', 1, 1, 1);
+        db.close();
+        const migratedStore = new MemoryStore(migrationDbPath, { ...TEST_CONFIG, wikiDir: migrationDir });
+        try {
+            const verifyDb = new Database(migrationDbPath, { readonly: true });
+            try {
+                assert.equal(verifyDb.pragma('user_version', { simple: true }), SCHEMA_VERSION);
+                const columns = verifyDb.prepare(`PRAGMA table_info(memory_chunks)`).all();
+                assert.ok(columns.some((column) => column.name === 'source_type'));
+                assert.ok(columns.some((column) => column.name === 'file_mtime_at'));
+                const indexes = verifyDb.prepare(`PRAGMA index_list(memory_chunks)`).all();
+                assert.ok(indexes.some((index) => index.name === 'idx_memory_chunks_type_mtime'));
+                const rowCount = verifyDb.prepare(`SELECT COUNT(*) AS count FROM memory_chunks`).get();
+                assert.equal(rowCount.count, 0);
+            }
+            finally {
+                verifyDb.close();
+            }
+        }
+        finally {
+            migratedStore.close();
+            fs.rmSync(migrationDir, { recursive: true, force: true });
+        }
+    });
 });

package/dist/services/memory/types.d.ts

@@ -1,17 +1,21 @@
 import type { ConversationDigestSettings } from '../digest/types.js';
 export declare enum EmbeddingModelName {
     TINY = "tiny",
-    SMALL = "small",
+    BASE = "base",
     LARGE = "large"
 }
+export declare const SOURCE_TYPES: readonly ["digest", "concept", "entity", "preference", "wiki"];
+export type SourceType = (typeof SOURCE_TYPES)[number];
 export interface MemoryChunk {
     id: string;
     source: string;
+    sourceType: SourceType;
     heading: string;
     headingLevel: number;
     content: string;
     lineStart: number;
     lineEnd: number;
+    fileMtimeAt: number;
 }
 export interface SearchResult {
     chunk: MemoryChunk;
@@ -34,3 +38,7 @@ export interface IndexStats {
     deleted: number;
     skipped: number;
 }
+export interface RecentSource {
+    source: string;
+    fileMtimeAt: number;
+}

package/dist/services/memory/types.js

@@ -1,6 +1,7 @@
 export var EmbeddingModelName;
 (function (EmbeddingModelName) {
     EmbeddingModelName["TINY"] = "tiny";
-    EmbeddingModelName["SMALL"] = "small";
+    EmbeddingModelName["BASE"] = "base";
     EmbeddingModelName["LARGE"] = "large";
 })(EmbeddingModelName || (EmbeddingModelName = {}));
+export const SOURCE_TYPES = ['digest', 'concept', 'entity', 'preference', 'wiki'];

package/dist/utils/paths.d.ts

@@ -1,3 +1,5 @@
+export declare const AGENT_KIT_HOME: string;
 export declare const CREDENTIALS_FILE: string;
+export declare const GLOBAL_SETTINGS_FILE: string;
 export declare const MODEL_CACHE_DIR: string;
 export declare const FASTEMBED_CACHE_DIR: string;

package/dist/utils/paths.js

@@ -1,6 +1,7 @@
 import * as os from 'os';
 import * as path from 'path';
-const AGENT_KIT_HOME = path.join(os.homedir(), '.agent-kit');
+export const AGENT_KIT_HOME = path.join(os.homedir(), '.agent-kit');
 export const CREDENTIALS_FILE = path.join(AGENT_KIT_HOME, 'credentials');
+export const GLOBAL_SETTINGS_FILE = path.join(AGENT_KIT_HOME, 'settings.json');
 export const MODEL_CACHE_DIR = path.join(AGENT_KIT_HOME, 'cache', 'models');
 export const FASTEMBED_CACHE_DIR = path.join(MODEL_CACHE_DIR, 'fastembed');

package/dist/utils/utils.d.ts

@@ -7,4 +7,5 @@ type McpTextResult = {
 };
 export declare function mcpText(text: string): McpTextResult;
 export declare function mcpJson(obj: unknown): McpTextResult;
+export declare function formatError(err: unknown): string;
 export {};

package/dist/utils/utils.js

@@ -3,9 +3,6 @@ export function getWorkspaceRoot() {
         process.env.CLAUDE_PROJECT_DIR ||
         process.env.CODEX_PROJECT_DIR ||
         process.env.GEMINI_PROJECT_DIR ||
-        process.env.CLAUDE_WORKSPACE ||
-        process.env.CODEX_WORKSPACE ||
-        process.env.GEMINI_WORKSPACE ||
         process.env.INIT_CWD ||
         process.env.PWD ||
         process.cwd());
@@ -16,3 +13,6 @@ export function mcpText(text) {
 export function mcpJson(obj) {
     return mcpText(JSON.stringify(obj, null, 2));
 }
+export function formatError(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.34",
+  "version": "1.0.35",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
   "main": "dist/server.js",
@@ -22,7 +22,7 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc && npm run bundle",
-    "bundle": "esbuild src/entrypoints/server.ts src/entrypoints/cli.ts --bundle --platform=node --format=esm --outdir=dist --external:node:* --external:better-sqlite3 --external:sqlite-vec --external:fastembed --external:node-llama-cpp --banner:js=\"import { createRequire } from 'module'; const require = createRequire(import.meta.url);\"",
+    "bundle": "esbuild src/entrypoints/server.ts src/entrypoints/cli.ts --bundle --platform=node --format=esm --outdir=dist --external:node:* --external:better-sqlite3 --external:sqlite-vec --external:fastembed --external:node-llama-cpp",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build",
     "test": "tsc && node --test $(find dist -name '*.test.js' | tr '\\n' ' ')"