@hanhnd/agent-kit 1.0.31 → 1.0.33

package/dist/{tools/config.d.ts → core/config/index.d.ts}

@@ -2,7 +2,8 @@
  * Configuration utilities
  * Shared configuration constants and loaders
  */
-import { type MemoryConfig } from '../memory/types.js';
+import type { MemoryConfig } from '../../services/memory/types.js';
+import type { ConversationDigestSettings } from '../../services/digest/types.js';
 /**
  * Default file extensions - expanded to support more languages
  * Used by kit_get_project_context and other tools
@@ -21,15 +22,9 @@ export { MemoryConfig };
  * Merge DEFAULT_MEMORY_CONFIG with settings.memory; resolve wikiDir when not explicitly set.
  */
 export declare function resolveMemoryConfig(settings: ProjectSettings, workspaceRoot: string): MemoryConfig;
-/**
- * Get file extensions - from settings.json or defaults
- * Allows project-specific customization
- */
-export declare function getFileExtensions(projectDir: string): string[];
-/**
- * Load project settings from .gemini/settings.json
- */
 export declare function loadProjectSettings(projectDir: string): ProjectSettings;
+export declare function writeProjectSettings(workspaceRoot: string, patch: Partial<ProjectSettings>): void;
+export declare function resolveConversationDigestConfig(settings: ProjectSettings): ConversationDigestSettings | undefined;
 /**
  * Sensitive files that agents are FORBIDDEN from reading/writing.
  */

package/dist/{tools/config.js → core/config/index.js}

@@ -4,7 +4,8 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { DEFAULT_MEMORY_CONFIG } from '../memory/types.js';
+import { DEFAULT_MEMORY_CONFIG } from '../../services/memory/constants.js';
+import { atomicWriteJsonFile } from '../../utils/files.js';
 /**
  * Default file extensions - expanded to support more languages
  * Used by kit_get_project_context and other tools
@@ -47,20 +48,6 @@ export function resolveMemoryConfig(settings, workspaceRoot) {
             : path.join(workspaceRoot, '.agent-kit', 'wiki'),
     };
 }
-/**
- * Get file extensions - from settings.json or defaults
- * Allows project-specific customization
- */
-export function getFileExtensions(projectDir) {
-    const settings = loadProjectSettings(projectDir);
-    if (settings.fileExtensions && Array.isArray(settings.fileExtensions)) {
-        return settings.fileExtensions;
-    }
-    return DEFAULT_EXTENSIONS;
-}
-/**
- * Load project settings from .gemini/settings.json
- */
 export function loadProjectSettings(projectDir) {
     const settingsPath = path.join(projectDir, '.agent-kit', 'settings.json');
     if (fs.existsSync(settingsPath)) {
@@ -73,6 +60,23 @@ export function loadProjectSettings(projectDir) {
     }
     return {};
 }
+export function writeProjectSettings(workspaceRoot, patch) {
+    const settingsPath = path.join(workspaceRoot, '.agent-kit', 'settings.json');
+    const current = loadProjectSettings(workspaceRoot);
+    atomicWriteJsonFile(settingsPath, { ...current, ...patch });
+}
+export function resolveConversationDigestConfig(settings) {
+    const digest = settings.memory?.conversationDigest;
+    if (!digest?.initialized || typeof digest.modelId !== 'string' || typeof digest.initializedAt !== 'string') {
+        return undefined;
+    }
+    return {
+        enabled: digest.enabled !== false,
+        initialized: true,
+        modelId: digest.modelId,
+        initializedAt: digest.initializedAt,
+    };
+}
 /**
  * Sensitive files that agents are FORBIDDEN from reading/writing.
  */
@@ -108,11 +112,4 @@ export const FORBIDDEN_PATTERNS = [
 /**
  * Directory name segments that are always blocked.
  */
-export const FORBIDDEN_DIRS = [
-    '.git',
-    '.ssh',
-    '.aws',
-    '.kube',
-    '.gnupg',
-    '.docker',
-];
+export const FORBIDDEN_DIRS = ['.git', '.ssh', '.aws', '.kube', '.gnupg', '.docker'];

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

@@ -0,0 +1,16 @@
+export declare const HANDOFF_TYPES: readonly ["brainstorm", "clarification", "plan", "ticket", "research", "scenario", "investigation"];
+type HandoffType = (typeof HANDOFF_TYPES)[number];
+type CanonicalHandoffType = 'brainstorm' | 'clarification' | 'plan' | 'ticket' | 'research' | 'scenario' | 'investigation';
+interface SavedHandoffLocation {
+    featureSlug: string;
+    canonicalType: CanonicalHandoffType;
+    filePath: string;
+    relativePath: string;
+}
+export declare function resolveHandoffPath(input: {
+    workspaceRoot: string;
+    type: HandoffType;
+    slug: string;
+    content: string;
+}): SavedHandoffLocation;
+export {};

package/dist/{tools/handoffs.js → core/handoffs/index.js}

@@ -12,7 +12,7 @@ const TICKET_ID_PATTERN = /\b[A-Z][A-Z0-9]+-\d+\b/;
 function findTicketId(value) {
     return value.match(TICKET_ID_PATTERN)?.[0].toLowerCase() ?? null;
 }
-export function sanitizeFeatureSlug(value) {
+function sanitizeFeatureSlug(value) {
     return value
         .replace(/[^a-zA-Z0-9-_]/g, '-')
         .replace(/-+/g, '-')
@@ -26,13 +26,13 @@ function contentSlugCandidate(content) {
         .find((line) => line.length > 0);
     return heading ?? content.replace(/\s+/g, ' ').trim().slice(0, 80);
 }
-export function normalizeHandoffType(type) {
+function normalizeHandoffType(type) {
     if (!HANDOFF_TYPES.includes(type)) {
         throw new Error(`Unsupported handoff type: ${type}`);
     }
     return type;
 }
-export function deriveFeatureSlug(input) {
+function deriveFeatureSlug(input) {
     const requestedTicketSlug = findTicketId(input.requestedSlug);
     if (requestedTicketSlug)
         return requestedTicketSlug;
@@ -42,8 +42,7 @@ export function deriveFeatureSlug(input) {
     const contentTicketSlug = findTicketId(input.content);
     if (contentTicketSlug)
         return contentTicketSlug;
-    return (sanitizeFeatureSlug(contentSlugCandidate(input.content)) ||
-        'untitled-handoff');
+    return sanitizeFeatureSlug(contentSlugCandidate(input.content)) || 'untitled-handoff';
 }
 export function resolveHandoffPath(input) {
     const canonicalType = normalizeHandoffType(input.type);

package/dist/{tools/security.d.ts → core/security/index.d.ts}

@@ -18,26 +18,7 @@ export declare function sanitize(input: string): string;
  * Uses stricter path.sep check to prevent prefix matching flaws.
  */
 export declare function validatePath(filePath: string, baseDir?: string): string;
-/**
- * Safe git command execution using execFileSync
- * Includes stderr in error message for better debugging
- *
- * @param timeout Default from GEMINI_KIT_GIT_TIMEOUT env var or 30s
- */
-export declare function safeGit(args: string[], options?: {
-    timeout?: number;
-    cwd?: string;
-}): string;
-/**
- * Check if a command exists (cross-platform)
- * Uses 'where' on Windows, 'which' on macOS/Linux
- */
 export declare function commandExists(cmd: string): boolean;
-/**
- * Async file finder - non-blocking for large repos
- * Uses queue-based approach to prevent stack overflow on deep directories
- */
-export declare function findFilesAsync(dir: string, extensions: string[], maxFiles: number, excludeDirs?: string[]): Promise<string[]>;
 /**
  * Sanitize output text by redacting sensitive tokens (API keys, etc.)
  */

package/dist/{tools/security.js → core/security/index.js}

@@ -3,10 +3,9 @@
  * Exported utilities for safe command execution
  */
 import { execFileSync } from 'child_process';
-import * as fs from 'fs';
 import * as path from 'path';
-import { getWorkspaceRoot } from '../utils/utils.js';
-import { FORBIDDEN_DIRS, FORBIDDEN_FILES, FORBIDDEN_PATTERNS } from './config.js';
+import { getWorkspaceRoot } from '../../utils/utils.js';
+import { FORBIDDEN_DIRS, FORBIDDEN_FILES, FORBIDDEN_PATTERNS } from '../config/index.js';
 /**
  * Sanitize string for safe use with execFileSync
  * Only removes dangerous shell operators - safe chars like !?#* are allowed
@@ -52,42 +51,6 @@ export function validatePath(filePath, baseDir = process.cwd()) {
     }
     return resolved;
 }
-/**
- * Extract stderr from error for better logging
- */
-function extractStderr(error) {
-    if (error && typeof error === 'object' && 'stderr' in error) {
-        return String(error.stderr);
-    }
-    return '';
-}
-// Configurable timeouts via environment variables
-const GIT_TIMEOUT = parseInt(process.env.GEMINI_KIT_GIT_TIMEOUT || '30000', 10);
-/**
- * Safe git command execution using execFileSync
- * Includes stderr in error message for better debugging
- *
- * @param timeout Default from GEMINI_KIT_GIT_TIMEOUT env var or 30s
- */
-export function safeGit(args, options) {
-    try {
-        return execFileSync('git', args, {
-            encoding: 'utf8',
-            timeout: options?.timeout || GIT_TIMEOUT,
-            cwd: options?.cwd || getWorkspaceRoot(),
-            maxBuffer: 10 * 1024 * 1024, // 10MB
-        });
-    }
-    catch (error) {
-        const stderr = extractStderr(error);
-        const baseMsg = error instanceof Error ? error.message : String(error);
-        throw new Error(`Git command failed: ${baseMsg}${stderr ? `\nDetails: ${stderr}` : ''}`);
-    }
-}
-/**
- * Check if a command exists (cross-platform)
- * Uses 'where' on Windows, 'which' on macOS/Linux
- */
 export function commandExists(cmd) {
     try {
         const checkCmd = process.platform === 'win32' ? 'where' : 'which';
@@ -103,46 +66,6 @@ export function commandExists(cmd) {
         return false;
     }
 }
-/**
- * Async file finder - non-blocking for large repos
- * Uses queue-based approach to prevent stack overflow on deep directories
- */
-export async function findFilesAsync(dir, extensions, maxFiles, excludeDirs = ['node_modules', '.git', 'dist', 'build', 'coverage']) {
-    const results = [];
-    // Use queue instead of recursion to prevent stack overflow
-    const queue = [
-        { fullPath: dir, relativePath: '' },
-    ];
-    while (queue.length > 0 && results.length < maxFiles) {
-        const current = queue.shift();
-        let entries;
-        try {
-            entries = await fs.promises.readdir(current.fullPath, { withFileTypes: true });
-        }
-        catch {
-            continue; // Skip directories we can't read
-        }
-        for (const entry of entries) {
-            if (results.length >= maxFiles)
-                break;
-            const entryFullPath = path.join(current.fullPath, entry.name);
-            const entryRelPath = current.relativePath
-                ? path.join(current.relativePath, entry.name)
-                : entry.name;
-            if (entry.isDirectory()) {
-                if (!excludeDirs.includes(entry.name)) {
-                    queue.push({ fullPath: entryFullPath, relativePath: entryRelPath });
-                }
-            }
-            else if (entry.isFile()) {
-                if (extensions.some((ext) => entry.name.endsWith(ext))) {
-                    results.push(entryRelPath);
-                }
-            }
-        }
-    }
-    return results;
-}
 /**
  * Sanitize output text by redacting sensitive tokens (API keys, etc.)
  */
@@ -152,7 +75,7 @@ export function sanitizeOutput(text) {
         /SK-[A-Za-z0-9]{40,}/g, // OpenAI keys
         /AKIA[0-9A-Z]{16}/g, // AWS access keys
         /xox[baprs]-[A-Za-z0-9-]{10,}/g, // Slack tokens
-        /[Aa]tlassian[_\-]?[Aa][Pp][Ii][_\-]?[Tt]oken[^\s]*\s*[:=]\s*\S+/g, // Atlassian token patterns
+        /[Aa]tlassian[_-]?[Aa][Pp][Ii][_-]?[Tt]oken[^\s]*\s*[:=]\s*\S+/g, // Atlassian token patterns
     ];
     let sanitized = text;
     for (const pattern of SECRET_PATTERNS) {

package/dist/entrypoints/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/entrypoints/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { runAgentKitCli } from '../cli/index.js';
+try {
+    const exitCode = await runAgentKitCli(process.argv.slice(2), process.env);
+    process.exit(exitCode);
+}
+catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write('[agent-kit] CLI error: ' + message + '\n');
+    process.exit(1);
+}

package/dist/entrypoints/server.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * Agent-Kit MCP Server
+ * Provides custom tools for agent orchestration
+ *
+ * Modular architecture - tools split into separate modules
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+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({
+    name: 'kit-agents',
+    version: '1.0.0',
+});
+// ═══════════════════════════════════════════════════════════════
+// REGISTER MODULAR TOOLS
+// ═══════════════════════════════════════════════════════════════
+registerIntegrationTools(server);
+registerCoreTools(server);
+registerAgentTools(server);
+const workspaceRoot = getWorkspaceRoot();
+const settings = loadProjectSettings(workspaceRoot);
+const memoryIndexer = registerMemoryTools(server, settings, workspaceRoot);
+// ═══════════════════════════════════════════════════════════════
+// START SERVER
+// ═══════════════════════════════════════════════════════════════
+const transport = new StdioServerTransport();
+await server.connect(transport);
+// Fire-and-forget startup indexing — must run after server.connect
+if (memoryIndexer) {
+    void memoryIndexer.startupIndex();
+}

package/dist/{tools → mcp}/agent.js

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { z } from 'zod';
 import { getWorkspaceRoot, mcpJson, mcpText } from '../utils/utils.js';
-import { commandExists, sanitizeOutput, validatePath } from './security.js';
+import { commandExists, sanitizeOutput, validatePath } from '../core/security/index.js';
 // Configurable timeout via environment variable (default: 5 minutes)
 const AGENT_TIMEOUT = parseInt(process.env.KIT_AGENT_TIMEOUT || '300000', 10);
 const jobRegistry = new Map();
@@ -24,16 +24,7 @@ function agentArgs(agent, prompt, workspaceRoot) {
         case 'claude':
             return ['--dangerously-skip-permissions', '-p', prompt];
         case 'codex':
-            return [
-                '--ask-for-approval',
-                'never',
-                '--sandbox',
-                'workspace-write',
-                '--cd',
-                workspaceRoot,
-                'exec',
-                prompt,
-            ];
+            return ['--ask-for-approval', 'never', '--sandbox', 'workspace-write', '--cd', workspaceRoot, 'exec', prompt];
     }
 }
 function taskSlug(task) {
@@ -59,9 +50,7 @@ function initAgentLog(workspaceRoot, slug, agent) {
 }
 export function registerAgentTools(server) {
     server.tool('kit_trigger_agent', '!Important: Trigger only when user explicitly asks to delegate a task to an external agent CLI (gemini, claude, or codex). The task can be a direct message or a path to a handoff file (.agent-kit/handoffs/feature-slug/plan.md).', {
-        agent: z
-            .enum(['gemini', 'claude', 'codex'])
-            .describe('The agent CLI to invoke: "gemini", "claude", or "codex"'),
+        agent: z.enum(['gemini', 'claude', 'codex']).describe('The agent CLI to invoke: "gemini", "claude", or "codex"'),
         task: z
             .string()
             .describe('Task message or path to a handoff file (e.g., ".agent-kit/handoffs/feature-slug/plan.md")'),

package/dist/{tools → mcp}/core.d.ts

@@ -2,7 +2,7 @@
  * Core Tools - Extension info and handoff persistence
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { DEFAULT_EXTENSIONS } from './config.js';
+import { DEFAULT_EXTENSIONS } from '../core/config/index.js';
 /**
  * Register core tools with MCP server
  */

package/dist/{tools → mcp}/core.js

@@ -5,8 +5,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { z } from 'zod';
 import { getWorkspaceRoot, mcpText } from '../utils/utils.js';
-import { DEFAULT_EXTENSIONS } from './config.js';
-import { HANDOFF_TYPES, resolveHandoffPath } from './handoffs.js';
+import { DEFAULT_EXTENSIONS } from '../core/config/index.js';
+import { HANDOFF_TYPES, resolveHandoffPath } from '../core/handoffs/index.js';
 /**
  * Register core tools with MCP server
  */
@@ -17,9 +17,7 @@ export function registerCoreTools(server) {
     // Returns the saved file path to use in next-step instructions
     // ═══════════════════════════════════════════════════════════════
     server.tool('kit_save_handoff', `Save a handoff artifact to .agent-kit/handoffs/. Returns the saved file path to use in next-step instructions. Do NOT append version numbers (v2, v3, etc.) to the slug.`, {
-        type: z
-            .enum(HANDOFF_TYPES)
-            .describe('Handoff type'),
+        type: z.enum(HANDOFF_TYPES).describe('Handoff type'),
         content: z.string().describe('Full markdown content to save'),
         slug: z
             .string()

package/dist/{tools → mcp}/integration.js

@@ -4,10 +4,10 @@
  */
 import { writeFileSync } from 'fs';
 import { z } from 'zod';
-import { getCredential } from '../utils/credentials.js';
+import { getCredential } from '../services/integration/credentials.js';
 import { mcpText } from '../utils/utils.js';
-import { adfToMarkdown } from '../utils/parser.js';
-import { sanitize } from './security.js';
+import { adfToMarkdown } from '../services/integration/parser/adf.js';
+import { sanitize } from '../core/security/index.js';
 // Zod schema for Bitbucket PR REST API response
 const BitbucketPrSchema = z.object({
     id: z.number(),
@@ -81,11 +81,7 @@ export function registerIntegrationTools(server) {
             .optional()
             .describe('Bitbucket workspace slug (required for numeric ID if BITBUCKET_DEFAULT_WORKSPACE not set)'),
         repoSlug: z.string().optional().describe('Bitbucket repo slug (required for numeric ID)'),
-        includeDiff: z
-            .boolean()
-            .optional()
-            .default(true)
-            .describe('Include unified diff in response'),
+        includeDiff: z.boolean().optional().default(true).describe('Include unified diff in response'),
     }, async ({ input, workspace, repoSlug, includeDiff }) => {
         try {
             let ws;
@@ -180,9 +176,7 @@ ${pr.description || 'No description'}`;
 **Type:** ${ticket.fields.issuetype?.name || 'Unknown'}
 
 ### Description
-${typeof ticket.fields.description === 'string'
-                ? ticket.fields.description
-                : adfToMarkdown(ticket.fields.description)}
+${typeof ticket.fields.description === 'string' ? ticket.fields.description : adfToMarkdown(ticket.fields.description)}
 
 ### Labels
 ${ticket.fields.labels?.join(', ') || 'None'}`;

package/dist/mcp/memory.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { MemoryIndexer } from '../services/memory/indexer.js';
+import { MemoryStore } from '../services/memory/store.js';
+import type { MemoryConfig } from '../services/memory/types.js';
+import { type ProjectSettings } from '../core/config/index.js';
+/**
+ * Initializes the memory subsystem and registers all memory tools.
+ * 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?: {
+    indexer?: MemoryIndexer;
+    store?: MemoryStore;
+    config?: MemoryConfig;
+}): MemoryIndexer | null;

package/dist/{tools → mcp}/memory.js

@@ -1,15 +1,16 @@
 import * as path from 'path';
 import { z } from 'zod';
-import { Embedder } from '../memory/embedder.js';
-import { MemoryIndexer } from '../memory/indexer.js';
-import { MemoryStore } from '../memory/store.js';
+import { Embedder } from '../services/memory/embedder.js';
+import { MemoryIndexer } from '../services/memory/indexer.js';
+import { MemoryStore } from '../services/memory/store.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 { resolveMemoryConfig } from './config.js';
+import { loadProjectSettings, resolveConversationDigestConfig, resolveMemoryConfig, } from '../core/config/index.js';
 /**
  * Registers tool handlers onto an already-constructed indexer/store pair.
- * Exported for unit testing with mocks.
  */
-export function registerMemoryToolHandlers(server, indexer, store, config) {
+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'),
         top_k: z.number().int().positive().optional().describe('Number of results to return'),
@@ -57,19 +58,46 @@ export function registerMemoryToolHandlers(server, indexer, store, config) {
             return mcpJson({ saved: false, error: message });
         }
     });
+    server.tool('kit_memory_digest_init', 'Initialize or toggle local conversation digesting. Downloads/cache-loads the pinned local model only when explicitly invoked.', {
+        model_id: z.string().optional().describe('Digest model id'),
+        enabled: z.boolean().optional().describe('Enable or disable conversation digesting'),
+    }, async ({ model_id, enabled }) => {
+        try {
+            const existingConfig = resolveConversationDigestConfig(loadProjectSettings(workspaceRoot));
+            const result = await initializeConversationDigestModel({
+                workspaceRoot,
+                modelId: model_id ?? existingConfig?.modelId ?? DEFAULT_DIGEST_MODEL_ID,
+                allowDownload: true,
+                enabled,
+            });
+            return mcpJson({
+                initialized: result.initialized,
+                model_id: result.modelId,
+                initialized_at: result.initializedAt,
+                error: result.error,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return mcpJson({ initialized: false, error: message });
+        }
+    });
 }
 /**
  * Initializes the memory subsystem and registers all memory tools.
  * 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) {
+export function registerMemoryTools(server, settings, workspaceRoot, overrides) {
     if (settings.memory?.enabled !== true)
         return null;
-    const config = resolveMemoryConfig(settings, workspaceRoot);
-    const store = new MemoryStore(path.join(config.wikiDir, 'index.db'), config);
-    const embedder = new Embedder(config.embeddingModel);
-    const indexer = new MemoryIndexer(store, embedder, config);
-    registerMemoryToolHandlers(server, indexer, store, config);
+    const config = overrides?.config ?? resolveMemoryConfig(settings, workspaceRoot);
+    const store = overrides?.store ?? new MemoryStore(path.join(config.wikiDir, 'index.db'), config);
+    const indexer = overrides?.indexer ??
+        (() => {
+            const embedder = new Embedder(config.embeddingModel);
+            return new MemoryIndexer(store, embedder, config);
+        })();
+    registerMemoryToolHandlers(server, indexer, store, config, workspaceRoot);
     return indexer;
 }