@hanhnd/agent-kit 1.0.32 → 1.0.33

package/dist/{memory → services}/digest/providers/llama-local.js

@@ -5,7 +5,7 @@ import { LLAMA_CONTEXT_SIZE, LLAMA_MAX_GENERATED_TOKENS, LLAMA_TEMPERATURE } fro
 import { getDigestModelSpec } from '../model-registry.js';
 import { withTimeout } from '../../../utils/async.js';
 import { MODEL_CACHE_DIR } from '../../../utils/paths.js';
-export class LlamaLocalDigestProviderError extends Error {
+class LlamaLocalDigestProviderError extends Error {
     constructor(message) {
         super(message);
         this.name = 'LlamaLocalDigestProviderError';
@@ -17,7 +17,7 @@ function titleFromSource(sourcePath) {
         .replace(/\.[^.]+$/, '')
         .replace(/[_-]+/g, ' ');
 }
-export function trimConversationExport(content, maxInputChars) {
+function trimConversationExport(content, maxInputChars) {
     const trimmed = content.trim();
     if (trimmed.length <= maxInputChars)
         return trimmed;
@@ -28,7 +28,6 @@ export function trimConversationExport(content, maxInputChars) {
 }
 function buildPrompt(input, maxInputChars) {
     const conversationExport = trimConversationExport(input.content, maxInputChars);
-    const sourceName = path.basename(input.sourcePath);
     return [
         {
             role: 'system',
@@ -75,7 +74,7 @@ function stripCodeFence(text) {
     const match = trimmed.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```$/i);
     return match ? match[1].trim() : trimmed;
 }
-export function sanitizeConversationDigestMarkdown(generatedText) {
+function sanitizeConversationDigestMarkdown(generatedText) {
     return stripCodeFence(generatedText).trim() + '\n';
 }
 export async function createLlamaLocalDigestProvider(modelId) {

package/dist/{memory → services}/digest/types.d.ts

@@ -1,3 +1,8 @@
+export declare enum DigestModelId {
+    TINY = "tiny",
+    DEFAULT = "default",
+    LARGE = "large"
+}
 export interface ConversationDigestSettings {
     enabled?: boolean;
     initialized: boolean;
@@ -5,7 +10,7 @@ export interface ConversationDigestSettings {
     initializedAt: string;
 }
 export interface DigestModelSpec {
-    id: string;
+    id: DigestModelId;
     ggufUri: string;
     approxSizeBytes: number;
     license: string;
@@ -17,7 +22,7 @@ export interface ConversationDigestInput {
     content: string;
     contentHash: string;
 }
-export interface ConversationDigestOptions {
+interface ConversationDigestOptions {
     modelId: string;
     maxInputChars: number;
     timeoutMs: number;
@@ -83,3 +88,30 @@ export type DigestPendingResult = {
     action: 'error';
     error: string;
 };
+export type DigestWorkerState = 'running' | 'complete' | 'failed' | 'not-initialized' | 'no-pending' | 'locked' | 'stale';
+export interface DigestWorkerStatus {
+    state: DigestWorkerState;
+    pid: number | null;
+    startedAt: string;
+    updatedAt: string;
+    pendingAtStart: number;
+    processed: number;
+    skipped: number;
+    errors: number;
+    lastError?: string;
+}
+export interface DigestPendingCandidateSummary {
+    initialized: boolean;
+    pending: number;
+    reason?: 'not-initialized' | 'no-pending';
+}
+export interface DigestPendingLauncherResult {
+    ok: boolean;
+    mode: 'background-launcher';
+    status: DigestWorkerStatus;
+    spawned: boolean;
+    pid?: number;
+    reason?: string;
+    error?: string;
+}
+export {};

package/dist/services/digest/types.js

@@ -0,0 +1,6 @@
+export var DigestModelId;
+(function (DigestModelId) {
+    DigestModelId["TINY"] = "tiny";
+    DigestModelId["DEFAULT"] = "default";
+    DigestModelId["LARGE"] = "large";
+})(DigestModelId || (DigestModelId = {}));

package/dist/{memory → services}/digest/worker.d.ts

@@ -1,3 +1,2 @@
-export declare function parseDigestWorkerSuccess(stdout: string): boolean;
 export declare function isDigestWorkerInvocation(args: string[]): boolean;
 export declare function runDigestFileInWorker(args: string[]): number | undefined;

package/dist/{memory → services}/digest/worker.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { parseArgs, numberFlag } from '../../utils/args.js';
+import { parseArgs, numberFlag } from '../../cli/utils/args.js';
 import { DEFAULT_DIGEST_TIMEOUT_MS, DIGEST_TIMEOUT_GRACE_MS, DIGEST_WORKER_FLAG, DIGEST_WORKER_RESULT_PREFIX, } from './constants.js';
 function isDigestWorkerResult(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
@@ -7,7 +7,7 @@ function isDigestWorkerResult(value) {
     const record = value;
     return typeof record.markdown === 'string' && record.status === 'provisional';
 }
-export function parseDigestWorkerSuccess(stdout) {
+function parseDigestWorkerSuccess(stdout) {
     const line = stdout
         .split(/\r?\n/)
         .reverse()

package/dist/{utils → services/integration}/credentials.js

@@ -14,7 +14,7 @@
  * Active profile: KIT_PROFILE env var (defaults to "default")
  */
 import * as fs from 'fs';
-import { CREDENTIALS_FILE } from './paths.js';
+import { CREDENTIALS_FILE } from '../../utils/paths.js';
 let cachedCredentials = null;
 /**
  * Parse a simple INI file into a map of profiles.

package/dist/{utils/parser.js → services/integration/parser/adf.js}

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 export function adfToMarkdown(adf) {
     if (!adf || typeof adf !== 'object')
         return 'No description';

package/dist/{memory → services/memory}/chunker.d.ts

@@ -1,4 +1,2 @@
 import type { MemoryChunk, MemoryConfig } from './types.js';
-export declare function computeChunkId(content: string): string;
-export declare function cleanContentForEmbedding(text: string): string;
 export declare function chunkMarkdown(text: string, source: string, config: Pick<MemoryConfig, 'chunkSize' | 'overlapLines'>): MemoryChunk[];

package/dist/{memory → services/memory}/chunker.js

@@ -1,8 +1,8 @@
-import { sha256Hex } from '../utils/hash.js';
-export function computeChunkId(content) {
+import { sha256Hex } from '../../utils/hash.js';
+function computeChunkId(content) {
     return sha256Hex(content).slice(0, 16);
 }
-export function cleanContentForEmbedding(text) {
+function cleanContentForEmbedding(text) {
     return text.replace(/<!--[\s\S]*?-->/g, '');
 }
 const HEADING_RE = /^(#{1,6}) (.+)$/;

package/dist/{memory/__tests__ → services/memory}/chunker.test.js

@@ -1,6 +1,6 @@
 import * as assert from 'node:assert/strict';
 import { describe, test } from 'node:test';
-import { chunkMarkdown, cleanContentForEmbedding, computeChunkId } from '../chunker.js';
+import { chunkMarkdown } from './chunker.js';
 const CFG = { chunkSize: 200, overlapLines: 2 };
 const SRC = 'test.md';
 describe('chunkMarkdown', () => {
@@ -70,36 +70,3 @@ describe('chunkMarkdown', () => {
         assert.ok(chunk.content.includes('Before.'), 'Text before comment must remain');
     });
 });
-describe('computeChunkId', () => {
-    test('returns 16-character hex string', () => {
-        const id = computeChunkId('hello world');
-        assert.equal(id.length, 16);
-        assert.match(id, /^[0-9a-f]{16}$/);
-    });
-    test('same content always produces same id', () => {
-        assert.equal(computeChunkId('abc'), computeChunkId('abc'));
-    });
-    test('different content produces different id', () => {
-        assert.notEqual(computeChunkId('abc'), computeChunkId('xyz'));
-    });
-});
-describe('cleanContentForEmbedding', () => {
-    test('strips HTML comment', () => {
-        assert.equal(cleanContentForEmbedding('hello <!-- comment --> world'), 'hello  world');
-    });
-    test('strips multiline HTML comment', () => {
-        const input = 'before <!-- line1\nline2 --> after';
-        const result = cleanContentForEmbedding(input);
-        assert.ok(!result.includes('line1'));
-        assert.ok(result.includes('before'));
-        assert.ok(result.includes('after'));
-    });
-    test('returns original string when no comments present', () => {
-        const text = 'plain text without comments';
-        assert.equal(cleanContentForEmbedding(text), text);
-    });
-    test('preserves fenced code block content', () => {
-        const text = '```js\nconst x = 1;\n```';
-        assert.equal(cleanContentForEmbedding(text), text);
-    });
-});

package/dist/{memory → services/memory}/constants.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryConfig } from './types.js';
+import { type MemoryConfig } from './types.js';
 export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
 export declare const LOCK_RETRY_MS = 50;
 export declare const LOCK_TIMEOUT_MS = 500;

package/dist/{memory → services/memory}/constants.js

@@ -1,10 +1,11 @@
+import { EmbeddingModelName } from './types.js';
 export const DEFAULT_MEMORY_CONFIG = {
     enabled: false,
     wikiDir: '',
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: 'Xenova/bge-small-en-v1.5',
+    embeddingModel: EmbeddingModelName.SMALL,
     vectorDimension: 384,
 };
 export const LOCK_RETRY_MS = 50;

package/dist/{memory → services/memory}/embedder.d.ts

@@ -1,4 +1,4 @@
-export { FASTEMBED_CACHE_DIR, MODEL_CACHE_DIR as DEFAULT_MODEL_CACHE_DIR } from '../utils/paths.js';
+import { EmbeddingModelName } from './types.js';
 export declare class EmbedderError extends Error {
     constructor(message: string, cause?: unknown);
 }
@@ -6,7 +6,7 @@ export declare class Embedder {
     private readonly modelName;
     private pipeline;
     private _dimension;
-    constructor(modelName: string);
+    constructor(modelName: EmbeddingModelName);
     embed(texts: string[]): Promise<Float32Array[]>;
     get dimension(): number | undefined;
     isReady(): boolean;

package/dist/{memory → services/memory}/embedder.js

@@ -1,5 +1,5 @@
-import { FASTEMBED_CACHE_DIR } from '../utils/paths.js';
-export { FASTEMBED_CACHE_DIR, MODEL_CACHE_DIR as DEFAULT_MODEL_CACHE_DIR } from '../utils/paths.js';
+import { FASTEMBED_CACHE_DIR } from '../../utils/paths.js';
+import { EmbeddingModelName } from './types.js';
 export class EmbedderError extends Error {
     constructor(message, cause) {
         super(message);
@@ -49,9 +49,9 @@ export class Embedder {
         try {
             const { EmbeddingModel, FlagEmbedding } = await import('fastembed');
             const modelMap = {
-                'Xenova/bge-small-en-v1.5': EmbeddingModel.BGESmallENV15,
-                'Xenova/bge-base-en-v1.5': EmbeddingModel.BGEBaseENV15,
-                'Xenova/all-MiniLM-L6-v2': EmbeddingModel.AllMiniLML6V2,
+                [EmbeddingModelName.TINY]: EmbeddingModel.AllMiniLML6V2,
+                [EmbeddingModelName.SMALL]: EmbeddingModel.BGESmallENV15,
+                [EmbeddingModelName.LARGE]: EmbeddingModel.BGEBaseENV15,
             };
             const model = modelMap[this.modelName] ?? EmbeddingModel.BGESmallENV15;
             const embedder = await FlagEmbedding.init({

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

@@ -0,0 +1,13 @@
+import * as assert from 'node:assert/strict';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { describe, test } from 'node:test';
+import { CREDENTIALS_FILE, MODEL_CACHE_DIR, FASTEMBED_CACHE_DIR } from '../../utils/paths.js';
+describe('Embedder cache paths', () => {
+    test('uses global Agent Kit home for user-level files', () => {
+        const home = path.join(os.homedir(), '.agent-kit');
+        assert.equal(CREDENTIALS_FILE, path.join(home, 'credentials'));
+        assert.equal(MODEL_CACHE_DIR, path.join(home, 'cache', 'models'));
+        assert.equal(FASTEMBED_CACHE_DIR, path.join(MODEL_CACHE_DIR, 'fastembed'));
+    });
+});

package/dist/{memory → services/memory}/indexer.d.ts

@@ -1,6 +1,6 @@
 import type { MemoryStore } from './store.js';
 import type { IndexStats, MemoryConfig, SearchResult } from './types.js';
-export interface TextEmbedder {
+interface TextEmbedder {
     embed(texts: string[]): Promise<Float32Array[]>;
     initialize(): Promise<void>;
 }
@@ -21,3 +21,4 @@ export declare class MemoryIndexer {
     startupIndex(): Promise<void>;
     get ready(): boolean;
 }
+export {};

package/dist/{memory → services/memory}/indexer.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { chunkMarkdown } from './chunker.js';
 import { LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RRF_K } from './constants.js';
-import { acquireLock, releaseLock } from '../utils/files.js';
+import { acquireLock, releaseLock } from '../../utils/files.js';
 export class MemoryIndexer {
     store;
     embedder;

package/dist/{memory/__tests__ → services/memory}/indexer.test.js

@@ -5,8 +5,9 @@ import { syncBuiltinESMExports } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { after, before, describe, test } from 'node:test';
-import { MemoryIndexer } from '../indexer.js';
-import { MemoryStore } from '../store.js';
+import { MemoryIndexer } from './indexer.js';
+import { MemoryStore } from './store.js';
+import { EmbeddingModelName } from './types.js';
 class StubEmbedder {
     async embed(texts) {
         return texts.map(() => new Float32Array(384).fill(0.05));
@@ -22,7 +23,7 @@ function makeConfig(wikiDir) {
         topK: 5,
         chunkSize: 1500,
         overlapLines: 2,
-        embeddingModel: 'Xenova/bge-small-en-v1.5',
+        embeddingModel: EmbeddingModelName.SMALL,
         vectorDimension: 384,
     };
 }

package/dist/{tools/__tests__ → services/memory}/memory.test.js

@@ -1,7 +1,8 @@
 import * as assert from 'node:assert/strict';
 import { describe, test } from 'node:test';
-import { resolveMemoryConfig } from '../config.js';
-import { registerMemoryToolHandlers } from '../memory.js';
+import { EmbeddingModelName } from './types.js';
+import { resolveMemoryConfig } from '../../core/config/index.js';
+import { registerMemoryTools } from '../../mcp/memory.js';
 // Minimal McpServer stub that captures tool registrations
 function makeMockServer() {
     const tools = new Map();
@@ -30,7 +31,7 @@ const BASE_CONFIG = {
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: 'Xenova/bge-small-en-v1.5',
+    embeddingModel: EmbeddingModelName.SMALL,
     vectorDimension: 384,
 };
 function makeIndexerStub(overrides = {}) {
@@ -61,7 +62,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [searchResult] });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test query' });
         const text = extractText(result);
         assert.ok(text.includes('Important memory content'), 'Result must include chunk content');
@@ -73,7 +78,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [] });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'nothing here' });
         const text = extractText(result);
         assert.ok(text.toLowerCase().includes('no memories') || text.includes('No memories'), `Expected "no memories" message, got: ${text.slice(0, 100)}`);
@@ -82,7 +91,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [] });
         const store = makeStoreStub(false);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('Vector search unavailable') || text.includes('keyword-only'), `Expected degraded warning in: ${text.slice(0, 200)}`);
@@ -98,7 +111,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [searchResult] });
         const store = makeStoreStub(false);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('Vector search unavailable') || text.includes('keyword-only'), `Expected degraded warning with results in: ${text.slice(0, 200)}`);
@@ -115,7 +132,11 @@ describe('kit_memory_search', () => {
         const indexer = makeIndexerStub({ search: async () => [searchResult] });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('Source file unavailable'), `Expected fallback warning in: ${text}`);
@@ -131,7 +152,11 @@ describe('kit_memory_search', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         await tools.get('kit_memory_search')({ query: 'test', top_k: 3 });
         assert.equal(capturedTopK, 3);
     });
@@ -145,7 +170,11 @@ describe('kit_memory_search', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         await tools.get('kit_memory_search')({ query: 'test' });
         assert.equal(capturedTopK, BASE_CONFIG.topK);
     });
@@ -157,7 +186,11 @@ describe('kit_memory_search', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_search')({ query: 'test' });
         const text = extractText(result);
         assert.ok(text.includes('kit_memory_search failed'), `Expected error prefix, got: ${text}`);
@@ -171,7 +204,11 @@ describe('kit_memory_save', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_save')({ content: 'Some important note' });
         const text = extractText(result);
         const parsed = JSON.parse(text);
@@ -187,7 +224,11 @@ describe('kit_memory_save', () => {
         });
         const store = makeStoreStub(true);
         const { server, tools } = makeMockServer();
-        registerMemoryToolHandlers(server, indexer, store, BASE_CONFIG);
+        registerMemoryTools(server, { memory: { enabled: true } }, '/tmp', {
+            indexer,
+            store,
+            config: BASE_CONFIG,
+        });
         const result = await tools.get('kit_memory_save')({ content: 'note' });
         const text = extractText(result);
         const parsed = JSON.parse(text);

package/dist/{memory/__tests__ → services/memory}/store.test.js

@@ -3,14 +3,15 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { after, before, describe, test } from 'node:test';
-import { MemoryStore } from '../store.js';
+import { MemoryStore } from './store.js';
+import { EmbeddingModelName } from './types.js';
 const TEST_CONFIG = {
     enabled: true,
     wikiDir: '',
     topK: 5,
     chunkSize: 1500,
     overlapLines: 2,
-    embeddingModel: 'Xenova/bge-small-en-v1.5',
+    embeddingModel: EmbeddingModelName.SMALL,
     vectorDimension: 384,
 };
 function makeChunk(overrides = {}) {

package/dist/{memory → services/memory}/types.d.ts

@@ -1,4 +1,9 @@
-import type { ConversationDigestSettings } from './digest/types.js';
+import type { ConversationDigestSettings } from '../digest/types.js';
+export declare enum EmbeddingModelName {
+    TINY = "tiny",
+    SMALL = "small",
+    LARGE = "large"
+}
 export interface MemoryChunk {
     id: string;
     source: string;
@@ -20,7 +25,7 @@ export interface MemoryConfig {
     topK: number;
     chunkSize: number;
     overlapLines: number;
-    embeddingModel: string;
+    embeddingModel: EmbeddingModelName;
     vectorDimension: number;
     conversationDigest?: ConversationDigestSettings;
 }

package/dist/services/memory/types.js

@@ -0,0 +1,6 @@
+export var EmbeddingModelName;
+(function (EmbeddingModelName) {
+    EmbeddingModelName["TINY"] = "tiny";
+    EmbeddingModelName["SMALL"] = "small";
+    EmbeddingModelName["LARGE"] = "large";
+})(EmbeddingModelName || (EmbeddingModelName = {}));

package/dist/utils/files.d.ts

@@ -1,6 +1,5 @@
 export declare function atomicWriteTextFile(filePath: string, content: string): void;
 export declare function atomicWriteJsonFile(filePath: string, value: unknown): void;
-export declare function tryWriteFileExclusive(filePath: string, content: string): boolean;
 export declare function acquireLock(lockPath: string, timeoutMs: number, retryMs: number): Promise<boolean>;
 export declare function releaseLock(lockPath: string, opts?: {
     ignoreErrors?: boolean;

package/dist/utils/files.js

@@ -9,7 +9,7 @@ export function atomicWriteTextFile(filePath, content) {
 export function atomicWriteJsonFile(filePath, value) {
     atomicWriteTextFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
-export function tryWriteFileExclusive(filePath, content) {
+function tryWriteFileExclusive(filePath, content) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     try {
         fs.writeFileSync(filePath, content, { flag: 'wx' });

package/dist/{memory/__tests__/lockfile.test.js → utils/files.test.js}

@@ -2,9 +2,9 @@ import * as assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { afterEach, describe, test } from 'node:test';
-import { createTempDirTracker } from '../../__tests__/temp-dir.js';
-import { DIGEST_LOCKFILE_REL_PATH } from '../digest/constants.js';
-import { releaseLock, tryAcquireProcessLock } from '../../utils/files.js';
+import { createTempDirTracker } from './temp-dir.test.js';
+import { DIGEST_LOCKFILE_REL_PATH } from '../services/digest/constants.js';
+import { releaseLock, tryAcquireProcessLock } from './files.js';
 const tempDirs = createTempDirTracker();
 afterEach(() => {
     tempDirs.cleanup();
@@ -12,20 +12,22 @@ afterEach(() => {
 function lockPath(workspace) {
     return path.join(workspace, DIGEST_LOCKFILE_REL_PATH);
 }
+function lockDir(workspace) {
+    return path.dirname(lockPath(workspace));
+}
 describe('tryAcquireProcessLock', () => {
     test('C1: no lockfile → creates it with current PID and returns true', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c1-');
         const acquired = tryAcquireProcessLock(lockPath(workspace));
         assert.equal(acquired, true);
-        const lockFile = path.join(workspace, '.agent-kit', 'digest-worker.lock');
+        const lockFile = lockPath(workspace);
         const content = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
         assert.equal(content.pid, process.pid);
     });
     test('C2: lockfile with live foreign PID → returns false without modifying file', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c2-');
-        const lockDir = path.join(workspace, '.agent-kit');
-        const lockFile = path.join(lockDir, 'digest-worker.lock');
-        fs.mkdirSync(lockDir, { recursive: true });
+        const lockFile = lockPath(workspace);
+        fs.mkdirSync(lockDir(workspace), { recursive: true });
         // Use process.pid as "live" pid (current process is definitely alive)
         const livePid = process.pid;
         fs.writeFileSync(lockFile, JSON.stringify({ pid: livePid }), 'utf8');
@@ -37,9 +39,8 @@ describe('tryAcquireProcessLock', () => {
     });
     test('C3: lockfile with dead PID (ESRCH) → deletes stale lock, creates new one, returns true', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c3-');
-        const lockDir = path.join(workspace, '.agent-kit');
-        const lockFile = path.join(lockDir, 'digest-worker.lock');
-        fs.mkdirSync(lockDir, { recursive: true });
+        const lockFile = lockPath(workspace);
+        fs.mkdirSync(lockDir(workspace), { recursive: true });
         // PID 999999999 is virtually guaranteed to be dead
         fs.writeFileSync(lockFile, JSON.stringify({ pid: 999999999 }), 'utf8');
         const acquired = tryAcquireProcessLock(lockPath(workspace));
@@ -57,9 +58,8 @@ describe('tryAcquireProcessLock', () => {
     });
     test('stale unparseable lockfile → treated as stale, returns true', () => {
         const workspace = tempDirs.makeTempDir('lockfile-stale-');
-        const lockDir = path.join(workspace, '.agent-kit');
-        const lockFile = path.join(lockDir, 'digest-worker.lock');
-        fs.mkdirSync(lockDir, { recursive: true });
+        const lockFile = lockPath(workspace);
+        fs.mkdirSync(lockDir(workspace), { recursive: true });
         fs.writeFileSync(lockFile, 'not-json', 'utf8');
         const acquired = tryAcquireProcessLock(lockPath(workspace));
         assert.equal(acquired, true);
@@ -69,7 +69,7 @@ describe('releaseLock', () => {
     test('C5: lockfile exists → deletes it', () => {
         const workspace = tempDirs.makeTempDir('lockfile-c5-');
         assert.equal(tryAcquireProcessLock(lockPath(workspace)), true);
-        const lockFile = path.join(workspace, '.agent-kit', 'digest-worker.lock');
+        const lockFile = lockPath(workspace);
         assert.equal(fs.existsSync(lockFile), true);
         releaseLock(lockPath(workspace));
         assert.equal(fs.existsSync(lockFile), false);

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './async.js';
+export * from './files.js';
+export * from './hash.js';
+export * from './json.js';
+export * from './paths.js';
+export * from './utils.js';

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+export * from './async.js';
+export * from './files.js';
+export * from './hash.js';
+export * from './json.js';
+export * from './paths.js';
+export * from './utils.js';

package/dist/utils/json.d.ts

@@ -1,2 +1 @@
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function readJsonObjectFile(filePath: string): Record<string, unknown>;

package/dist/utils/json.js

@@ -1,13 +1,3 @@
-import * as fs from 'node:fs';
 export function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-export function readJsonObjectFile(filePath) {
-    if (!fs.existsSync(filePath))
-        return {};
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    if (!isRecord(parsed)) {
-        throw new Error(`${filePath} must contain a JSON object`);
-    }
-    return parsed;
-}

package/dist/utils/paths.d.ts

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