@hanhnd/agent-kit 1.0.28 → 1.0.29

package/dist/kit-server.js

@@ -6,7 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -3223,8 +3229,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path6) {
-      let input = path6;
+    function removeDotSegments(path11) {
+      let input = path11;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3423,8 +3429,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path6, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path6 && path6 !== "/" ? path6 : void 0;
+        const [path11, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path11 && path11 !== "/" ? path11 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3589,49 +3595,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative2, options, skipNormalization) {
+    function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative2 = parse3(serialize(relative2, options), options);
+        relative3 = parse3(serialize(relative3, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options.tolerant && relative3.scheme) {
+        target.scheme = relative3.scheme;
+        target.userinfo = relative3.userinfo;
+        target.host = relative3.host;
+        target.port = relative3.port;
+        target.path = removeDotSegments(relative3.path || "");
+        target.query = relative3.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
+          target.userinfo = relative3.userinfo;
+          target.host = relative3.host;
+          target.port = relative3.port;
+          target.path = removeDotSegments(relative3.path || "");
+          target.query = relative3.query;
         } else {
-          if (!relative2.path) {
+          if (!relative3.path) {
             target.path = base.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative3.query !== void 0) {
+              target.query = relative3.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative3.path[0] === "/") {
+              target.path = removeDotSegments(relative3.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative3.path;
               } else if (!base.path) {
-                target.path = relative2.path;
+                target.path = relative3.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative3.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative3.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3639,7 +3645,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative3.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -6786,12 +6792,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs4, exportName) {
+    function addFormats(ajv, list, fs7, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs4[f]);
+        ajv.addFormat(f, fs7[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -7277,8 +7283,8 @@ function getErrorMap() {
 
 // ../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7394,11 +7400,11 @@ var errorUtil;
 
 // ../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -11036,10 +11042,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11359,11 +11365,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -20990,12 +20996,12 @@ var StdioServerTransport = class {
 };
 
 // src/tools/core.ts
-import * as fs from "fs";
-import * as path2 from "path";
+import * as fs2 from "fs";
+import * as path3 from "path";
 
 // src/utils/utils.ts
 function getWorkspaceRoot() {
-  return process.env.WORKSPACE_DIR || process.env.CODEX_WORKSPACE || process.env.CODEX_PROJECT_DIR || process.env.CLAUDE_WORKSPACE || process.env.GEMINI_WORKSPACE || process.env.INIT_CWD || process.env.PWD || process.cwd();
+  return process.env.WORKSPACE_DIR || 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();
 }
 function mcpText(text) {
   return { content: [{ type: "text", text }] };
@@ -21005,6 +21011,41 @@ function mcpJson(obj) {
 }
 
 // src/tools/config.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/memory/types.ts
+var DEFAULT_MEMORY_CONFIG = {
+  enabled: false,
+  wikiDir: "",
+  topK: 5,
+  chunkSize: 1500,
+  overlapLines: 2,
+  embeddingModel: "Xenova/bge-small-en-v1.5",
+  vectorDimension: 384
+};
+
+// src/tools/config.ts
+function resolveMemoryConfig(settings2, workspaceRoot2) {
+  const override = settings2.memory ?? {};
+  return {
+    ...DEFAULT_MEMORY_CONFIG,
+    ...override,
+    enabled: override.enabled ?? DEFAULT_MEMORY_CONFIG.enabled,
+    wikiDir: typeof override.wikiDir === "string" && override.wikiDir.length > 0 ? override.wikiDir : path.join(workspaceRoot2, ".agent-kit", "wiki")
+  };
+}
+function loadProjectSettings(projectDir) {
+  const settingsPath = path.join(projectDir, ".agent-kit", "settings.json");
+  if (fs.existsSync(settingsPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    } catch (error2) {
+      console.error(`[agent-kit] Warning: Failed to parse ${settingsPath}:`, error2);
+    }
+  }
+  return {};
+}
 var FORBIDDEN_FILES = [
   ".env",
   ".bashrc",
@@ -21046,7 +21087,7 @@ var FORBIDDEN_DIRS = [
 ];
 
 // src/tools/handoffs.ts
-import * as path from "path";
+import * as path2 from "path";
 var HANDOFF_TYPES = [
   "brainstorm",
   "clarification",
@@ -21089,11 +21130,11 @@ function resolveHandoffPath(input) {
     content: input.content,
     type: canonicalType
   });
-  const relativePath = path.join(".agent-kit", "handoffs", featureSlug, `${canonicalType}.md`);
+  const relativePath = path2.join(".agent-kit", "handoffs", featureSlug, `${canonicalType}.md`);
   return {
     featureSlug,
     canonicalType,
-    filePath: path.join(input.workspaceRoot, relativePath),
+    filePath: path2.join(input.workspaceRoot, relativePath),
     relativePath
   };
 }
@@ -21118,11 +21159,11 @@ function registerCoreTools(server2) {
           slug,
           content
         });
-        const handoffDir = path2.dirname(location.filePath);
-        if (!fs.existsSync(handoffDir)) {
-          fs.mkdirSync(handoffDir, { recursive: true });
+        const handoffDir = path3.dirname(location.filePath);
+        if (!fs2.existsSync(handoffDir)) {
+          fs2.mkdirSync(handoffDir, { recursive: true });
         }
-        fs.writeFileSync(location.filePath, content, "utf8");
+        fs2.writeFileSync(location.filePath, content, "utf8");
         return mcpText(`\u2705 Saved to: ${location.filePath}`);
       } catch (error2) {
         return mcpText(`Error saving handoff: ${error2}`);
@@ -21134,28 +21175,28 @@ function registerCoreTools(server2) {
 // src/tools/agent.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import * as fs2 from "fs";
-import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path5 from "path";
 
 // src/tools/security.ts
 import { execFileSync } from "child_process";
-import * as path3 from "path";
+import * as path4 from "path";
 function sanitize(input) {
   return String(input).replace(/[;&|`$<>\\]/g, "").trim().slice(0, 500);
 }
 function validatePath(filePath, baseDir = process.cwd()) {
-  const resolved = path3.resolve(baseDir, filePath);
-  const root = path3.resolve(baseDir);
-  if (resolved !== root && !resolved.startsWith(root + path3.sep)) {
+  const resolved = path4.resolve(baseDir, filePath);
+  const root = path4.resolve(baseDir);
+  if (resolved !== root && !resolved.startsWith(root + path4.sep)) {
     throw new Error(`Path traversal detected: ${filePath}`);
   }
-  const segments = resolved.split(path3.sep);
+  const segments = resolved.split(path4.sep);
   for (const segment of segments) {
     if (FORBIDDEN_DIRS.some((d) => segment.toLowerCase() === d.toLowerCase())) {
       throw new Error(`Access to sensitive directory is FORBIDDEN: ${segment}`);
     }
   }
-  const fileName = path3.basename(resolved);
+  const fileName = path4.basename(resolved);
   const isExactForbidden = FORBIDDEN_FILES.some((f) => fileName.toLowerCase() === f.toLowerCase());
   const isPatternForbidden = FORBIDDEN_PATTERNS.some((re) => re.test(fileName));
   if (isExactForbidden || isPatternForbidden) {
@@ -21206,7 +21247,7 @@ var INSTALL_HINTS = {
   claude: "Install Claude CLI: npm install -g @anthropic-ai/claude-code",
   codex: "Install Codex CLI: npm install -g @openai/codex"
 };
-function agentArgs(agent, prompt, workspaceRoot) {
+function agentArgs(agent, prompt, workspaceRoot2) {
   switch (agent) {
     case "gemini":
       return ["-y", "-p", prompt];
@@ -21219,7 +21260,7 @@ function agentArgs(agent, prompt, workspaceRoot) {
         "--sandbox",
         "workspace-write",
         "--cd",
-        workspaceRoot,
+        workspaceRoot2,
         "exec",
         prompt
       ];
@@ -21228,21 +21269,21 @@ function agentArgs(agent, prompt, workspaceRoot) {
 function taskSlug(task) {
   return task.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 6).join("-").slice(0, 48);
 }
-function initAgentLog(workspaceRoot, slug, agent) {
-  const logsDir = path4.join(workspaceRoot, ".agent-kit", "logs", "agents");
-  fs2.mkdirSync(logsDir, { recursive: true });
+function initAgentLog(workspaceRoot2, slug, agent) {
+  const logsDir = path5.join(workspaceRoot2, ".agent-kit", "logs", "agents");
+  fs3.mkdirSync(logsDir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const logFile = path4.join(logsDir, `delegate-${now}-${slug}.log`);
+  const logFile = path5.join(logsDir, `delegate-${now}-${slug}.log`);
   const header = `Agent: ${agent}
 Date: ${now}
 ${"\u2500".repeat(60)}
 
 `;
-  fs2.writeFileSync(logFile, header, "utf-8");
-  const logStream = fs2.createWriteStream(logFile, { flags: "a" });
+  fs3.writeFileSync(logFile, header, "utf-8");
+  const logStream = fs3.createWriteStream(logFile, { flags: "a" });
   logStream.on("error", () => {
   });
-  return { logPath: path4.relative(workspaceRoot, logFile), logStream };
+  return { logPath: path5.relative(workspaceRoot2, logFile), logStream };
 }
 function registerAgentTools(server2) {
   server2.tool(
@@ -21255,17 +21296,17 @@ function registerAgentTools(server2) {
       )
     },
     async ({ agent, task }, extra) => {
-      const workspaceRoot = getWorkspaceRoot();
+      const workspaceRoot2 = getWorkspaceRoot();
       let job;
       let logPath;
       let killChild;
       try {
         let prompt = task;
-        const resolvedTask = path4.resolve(workspaceRoot, task);
-        if (fs2.existsSync(resolvedTask) && fs2.statSync(resolvedTask).isFile()) {
+        const resolvedTask = path5.resolve(workspaceRoot2, task);
+        if (fs3.existsSync(resolvedTask) && fs3.statSync(resolvedTask).isFile()) {
           try {
-            validatePath(task, workspaceRoot);
-            prompt = fs2.readFileSync(resolvedTask, "utf-8");
+            validatePath(task, workspaceRoot2);
+            prompt = fs3.readFileSync(resolvedTask, "utf-8");
           } catch (err) {
             return mcpText(`Error reading task file: ${err}`);
           }
@@ -21278,17 +21319,17 @@ function registerAgentTools(server2) {
             error: `${agent} CLI is not installed. ${INSTALL_HINTS[agent]}`
           });
         }
-        const args = agentArgs(agent, prompt, workspaceRoot);
-        const { logPath: lp, logStream } = initAgentLog(workspaceRoot, taskSlug(task), agent);
+        const args = agentArgs(agent, prompt, workspaceRoot2);
+        const { logPath: lp, logStream } = initAgentLog(workspaceRoot2, taskSlug(task), agent);
         logPath = lp;
         const jobId = randomUUID();
         const child = spawn(agent, args, {
-          cwd: workspaceRoot,
+          cwd: workspaceRoot2,
           env: {
             ...process.env,
-            CODEX_PROJECT_DIR: workspaceRoot,
-            CODEX_WORKSPACE: workspaceRoot,
-            GEMINI_WORKSPACE: workspaceRoot
+            CODEX_PROJECT_DIR: workspaceRoot2,
+            CODEX_WORKSPACE: workspaceRoot2,
+            GEMINI_WORKSPACE: workspaceRoot2
           },
           detached: process.platform !== "win32"
         });
@@ -21366,10 +21407,10 @@ function registerAgentTools(server2) {
 import { writeFileSync as writeFileSync3 } from "fs";
 
 // src/utils/credentials.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as os from "os";
-import * as path5 from "path";
-var CREDENTIALS_FILE = path5.join(os.homedir(), ".claude", "credentials");
+import * as path6 from "path";
+var CREDENTIALS_FILE = path6.join(os.homedir(), ".claude", "credentials");
 var cachedCredentials = null;
 function parseIni(content) {
   const result = {};
@@ -21394,12 +21435,12 @@ function parseIni(content) {
 }
 function loadCredentials() {
   if (cachedCredentials !== null) return cachedCredentials;
-  if (!fs3.existsSync(CREDENTIALS_FILE)) {
+  if (!fs4.existsSync(CREDENTIALS_FILE)) {
     cachedCredentials = {};
     return cachedCredentials;
   }
   try {
-    const stat = fs3.statSync(CREDENTIALS_FILE);
+    const stat = fs4.statSync(CREDENTIALS_FILE);
     const mode = stat.mode & 511;
     if (mode !== 384) {
       process.stderr.write(
@@ -21409,7 +21450,7 @@ function loadCredentials() {
     }
   } catch {
   }
-  const content = fs3.readFileSync(CREDENTIALS_FILE, "utf-8");
+  const content = fs4.readFileSync(CREDENTIALS_FILE, "utf-8");
   const ini = parseIni(content);
   const profile = process.env.KIT_PROFILE ?? "default";
   cachedCredentials = ini[profile] ?? {};
@@ -21742,6 +21783,714 @@ ${ticket.fields.labels?.join(", ") || "None"}`;
   );
 }
 
+// src/tools/memory.ts
+import * as path10 from "path";
+
+// src/memory/embedder.ts
+import * as os2 from "os";
+import * as path7 from "path";
+var DEFAULT_CACHE_DIR = path7.join(os2.homedir(), ".cache", "fastembed");
+var EmbedderError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "EmbedderError";
+    if (cause instanceof Error) this.cause = cause;
+  }
+};
+var Embedder = class {
+  modelName;
+  pipeline = null;
+  _dimension;
+  constructor(modelName) {
+    this.modelName = modelName;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    if (!this.pipeline) {
+      await this.loadModel();
+    }
+    try {
+      const results = await this.pipeline(texts);
+      return results.map((vec) => {
+        const arr = new Float32Array(vec);
+        if (!this._dimension) this._dimension = arr.length;
+        return arr;
+      });
+    } catch (cause) {
+      throw new EmbedderError(`Embedding failed for batch of ${texts.length} texts`, cause);
+    }
+  }
+  get dimension() {
+    return this._dimension;
+  }
+  isReady() {
+    return this.pipeline !== null;
+  }
+  async loadModel() {
+    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
+      };
+      const model = modelMap[this.modelName] ?? EmbeddingModel.BGESmallENV15;
+      const embedder = await FlagEmbedding.init({ model, cacheDir: DEFAULT_CACHE_DIR, showDownloadProgress: false });
+      this.pipeline = async (texts) => {
+        const result = [];
+        for await (const batch of embedder.embed(texts, texts.length)) {
+          for (const vec of batch) {
+            result.push(Array.from(vec));
+          }
+        }
+        return result;
+      };
+    } catch (cause) {
+      throw new EmbedderError(`Failed to load embedding model: ${this.modelName}`, cause);
+    }
+  }
+};
+
+// src/memory/indexer.ts
+import * as fs5 from "fs";
+import * as path8 from "path";
+
+// src/memory/chunker.ts
+import { createHash } from "crypto";
+function computeChunkId(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function cleanContentForEmbedding(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, "");
+}
+var HEADING_RE = /^(#{1,6}) (.+)$/;
+var SENTENCE_END_RE = /([.!?。！？])\s+(?![0-9])/g;
+var URL_RE = /https?:\/\/\S+/g;
+function splitAtParagraph(text, maxLen) {
+  const paragraphs = text.split(/\n\n+/);
+  const parts = [];
+  let current = "";
+  for (const para of paragraphs) {
+    const candidate = current ? `${current}
+
+${para}` : para;
+    if (candidate.length <= maxLen) {
+      current = candidate;
+    } else {
+      if (current) parts.push(current);
+      current = para.length <= maxLen ? para : splitAtLine(para, maxLen).join("\n\n");
+    }
+  }
+  if (current) parts.push(current);
+  return parts.filter(Boolean);
+}
+function splitAtLine(text, maxLen) {
+  const lines = text.split("\n");
+  const parts = [];
+  let current = "";
+  for (const line of lines) {
+    const candidate = current ? `${current}
+${line}` : line;
+    if (candidate.length <= maxLen) {
+      current = candidate;
+    } else {
+      if (current) parts.push(current);
+      current = line.length <= maxLen ? line : splitAtSentence(line, maxLen).join(" ");
+    }
+  }
+  if (current) parts.push(current);
+  return parts.filter(Boolean);
+}
+function splitAtSentence(text, maxLen) {
+  const sanitized = text.replace(URL_RE, "[URL]");
+  const sentences = [];
+  let lastIndex = 0;
+  for (const match of sanitized.matchAll(SENTENCE_END_RE)) {
+    const end = (match.index ?? 0) + match[0].length;
+    sentences.push(text.slice(lastIndex, end).trim());
+    lastIndex = end;
+  }
+  if (lastIndex < text.length) {
+    sentences.push(text.slice(lastIndex).trim());
+  }
+  if (sentences.length === 0) return [text.slice(0, maxLen)];
+  const parts = [];
+  let current = "";
+  for (const sentence of sentences) {
+    const candidate = current ? `${current} ${sentence}` : sentence;
+    if (candidate.length <= maxLen) {
+      current = candidate;
+    } else {
+      if (current) parts.push(current);
+      current = sentence.slice(0, maxLen);
+    }
+  }
+  if (current) parts.push(current);
+  return parts.filter(Boolean);
+}
+function splitSection(text, maxLen) {
+  if (text.length <= maxLen) return [text];
+  const byPara = splitAtParagraph(text, maxLen);
+  if (byPara.every((p) => p.length <= maxLen)) return byPara;
+  return byPara.flatMap((p) => p.length <= maxLen ? [p] : splitAtLine(p, maxLen));
+}
+function chunkMarkdown(text, source, config2) {
+  if (!text || !text.trim()) return [];
+  const { chunkSize, overlapLines } = config2;
+  const lines = text.split("\n");
+  const sections = [];
+  let current = { heading: "", headingLevel: 0, lines: [] };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headingMatch = line.match(HEADING_RE);
+    if (headingMatch) {
+      if (current.lines.length > 0) sections.push(current);
+      current = {
+        heading: headingMatch[2].trim(),
+        headingLevel: headingMatch[1].length,
+        lines: [{ text: line, lineNum: i + 1 }]
+      };
+    } else {
+      current.lines.push({ text: line, lineNum: i + 1 });
+    }
+  }
+  if (current.lines.length > 0) sections.push(current);
+  const chunks = [];
+  let prevOverlapLines = [];
+  for (const section of sections) {
+    const sectionText = section.lines.map((l) => l.text).join("\n");
+    if (!sectionText.trim()) continue;
+    const fullText = prevOverlapLines.length > 0 ? `${prevOverlapLines.join("\n")}
+${sectionText}` : sectionText;
+    const parts = splitSection(fullText, chunkSize);
+    for (let pi = 0; pi < parts.length; pi++) {
+      const part = parts[pi];
+      if (!part.trim()) continue;
+      const partLines = part.split("\n");
+      const firstLine = section.lines[0]?.lineNum ?? 1;
+      const lastLine = section.lines[section.lines.length - 1]?.lineNum ?? firstLine;
+      const content = cleanContentForEmbedding(part);
+      chunks.push({
+        id: computeChunkId(content),
+        source,
+        heading: section.heading,
+        headingLevel: section.headingLevel,
+        content,
+        lineStart: firstLine,
+        lineEnd: lastLine
+      });
+      if (pi === parts.length - 1) {
+        prevOverlapLines = partLines.slice(-overlapLines);
+      }
+    }
+  }
+  return chunks;
+}
+
+// src/memory/indexer.ts
+var LOCK_RETRY_MS = 50;
+var LOCK_TIMEOUT_MS = 500;
+async function acquireLock(lockPath) {
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      fs5.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+      return true;
+    } catch {
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+  return false;
+}
+function releaseLock(lockPath) {
+  try {
+    fs5.unlinkSync(lockPath);
+  } catch {
+  }
+}
+var MemoryIndexer = class {
+  constructor(store, embedder, config2) {
+    this.store = store;
+    this.embedder = embedder;
+    this.config = config2;
+  }
+  _ready = false;
+  async indexFile(absolutePath) {
+    return this.indexFileRelativeTo(absolutePath, this.config.wikiDir);
+  }
+  async indexFileRelativeTo(absolutePath, sourceRoot) {
+    const source = path8.relative(sourceRoot, absolutePath);
+    const existingHashes = this.store.hashesBySource(source);
+    let text;
+    try {
+      text = fs5.readFileSync(absolutePath, "utf8");
+    } catch (err) {
+      console.warn(`[memory-indexer] Cannot read file ${absolutePath}:`, err);
+      return { indexed: 0, deleted: 0, skipped: existingHashes.size };
+    }
+    const allChunks = chunkMarkdown(text, source, this.config);
+    const newHashes = new Set(allChunks.map((c) => c.id));
+    const toIndex = allChunks.filter((c) => !existingHashes.has(c.id));
+    const toDelete = [...existingHashes].filter((h) => !newHashes.has(h));
+    let embeddings = [];
+    if (toIndex.length > 0) {
+      try {
+        embeddings = await this.embedder.embed(toIndex.map((c) => c.content));
+      } catch (err) {
+        console.warn(`[memory-indexer] Embedding failed for ${absolutePath}:`, err);
+        return { indexed: 0, deleted: 0, skipped: existingHashes.size };
+      }
+    }
+    if (toIndex.length > 0) {
+      this.store.upsert(toIndex, embeddings);
+    }
+    if (toDelete.length > 0) {
+      this.store.deleteByIds(toDelete);
+    }
+    return {
+      indexed: toIndex.length,
+      deleted: toDelete.length,
+      skipped: allChunks.length - toIndex.length
+    };
+  }
+  async indexDirectory(rootDir, opts = {}) {
+    const totals = { indexed: 0, deleted: 0, skipped: 0 };
+    if (!fs5.existsSync(rootDir)) return totals;
+    const relativeBase = opts.relativeBase ?? this.config.wikiDir;
+    const excludeFiles = new Set(opts.excludeFiles ?? []);
+    const files = [];
+    const walk = (dirPath) => {
+      let entries;
+      try {
+        entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+      } catch (err) {
+        console.warn(`[memory-indexer] Cannot scan directory ${dirPath}:`, err);
+        return;
+      }
+      for (const entry of entries) {
+        const entryPath = path8.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          walk(entryPath);
+          continue;
+        }
+        if (entry.isFile() && /\.md$/i.test(entry.name) && !excludeFiles.has(entry.name)) {
+          files.push(entryPath);
+        }
+      }
+    };
+    walk(rootDir);
+    const currentSources = new Set(
+      files.map((file) => path8.relative(relativeBase, file))
+    );
+    for (const stale of this.store.indexedSources()) {
+      if (!currentSources.has(stale)) {
+        this.store.deleteBySource(stale);
+        totals.deleted += 1;
+      }
+    }
+    for (const file of files) {
+      const stats = await this.indexFileRelativeTo(file, relativeBase);
+      totals.indexed += stats.indexed;
+      totals.deleted += stats.deleted;
+      totals.skipped += stats.skipped;
+    }
+    return totals;
+  }
+  async search(query, topK) {
+    const fetchLimit = topK * 2;
+    let denseResults = [];
+    if (this.store.vecAvailable) {
+      try {
+        const queryEmbedding = await this.embedder.embed([query]);
+        denseResults = this.store.searchDense(queryEmbedding[0], fetchLimit);
+      } catch (err) {
+        console.warn("[memory-indexer] Dense search embedding failed:", err);
+      }
+    }
+    const bm25Results = this.store.searchBm25(query, fetchLimit);
+    const k = 60;
+    const scoreMap = /* @__PURE__ */ new Map();
+    denseResults.forEach((r, rank) => {
+      scoreMap.set(r.id, { dense: 1 / (k + rank + 1), bm25: 0 });
+    });
+    bm25Results.forEach((r, rank) => {
+      const existing = scoreMap.get(r.id);
+      if (existing) {
+        existing.bm25 = 1 / (k + rank + 1);
+      } else {
+        scoreMap.set(r.id, { dense: 0, bm25: 1 / (k + rank + 1) });
+      }
+    });
+    const hasDense = this.store.vecAvailable && denseResults.length > 0;
+    const numRetrievers = hasDense ? 2 : 1;
+    const maxScore = numRetrievers / 61;
+    const ranked = [...scoreMap.entries()].map(([id, scores]) => ({
+      id,
+      totalScore: scores.dense + scores.bm25,
+      hasDense: scores.dense > 0,
+      hasBm25: scores.bm25 > 0
+    })).sort((a, b) => b.totalScore - a.totalScore);
+    const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
+    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+    const results = [];
+    const seenSources = /* @__PURE__ */ new Set();
+    for (const r of ranked) {
+      if (results.length >= topK) break;
+      const chunk = chunkMap.get(r.id);
+      if (!chunk) continue;
+      if (seenSources.has(chunk.source)) continue;
+      seenSources.add(chunk.source);
+      const normalizedScore = maxScore > 0 ? r.totalScore / maxScore : 0;
+      const retriever = r.hasDense && r.hasBm25 ? "both" : r.hasDense ? "dense" : "bm25";
+      let contentSource = "file";
+      try {
+        chunk.content = fs5.readFileSync(path8.join(this.config.wikiDir, chunk.source), "utf8");
+      } catch {
+        contentSource = "fallback";
+      }
+      results.push({ chunk, score: normalizedScore, retriever, contentSource });
+    }
+    return results;
+  }
+  async save(content) {
+    const datePart = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const rawDir = path8.join(this.config.wikiDir, "raw");
+    const savePath = path8.join(rawDir, `conv_save_${datePart}.md`);
+    const lockPath = `${savePath}.lock`;
+    fs5.mkdirSync(rawDir, { recursive: true });
+    const acquired = await acquireLock(lockPath);
+    if (!acquired) {
+      console.warn("[memory-indexer] Could not acquire write lock, writing anyway (fail-open)");
+    }
+    try {
+      fs5.appendFileSync(savePath, `
+${content}
+`, "utf8");
+    } finally {
+      if (acquired) releaseLock(lockPath);
+    }
+    return { indexed: 0, deleted: 0, skipped: 0 };
+  }
+  async startupIndex() {
+    try {
+      await this.indexDirectory(path8.join(this.config.wikiDir, "compiled"), {
+        relativeBase: this.config.wikiDir,
+        excludeFiles: ["index.md", "log.md"]
+      });
+    } catch (err) {
+      console.warn("[memory-indexer] Startup indexing failed:", err);
+    } finally {
+      this._ready = true;
+    }
+  }
+  get ready() {
+    return this._ready;
+  }
+};
+
+// src/memory/store.ts
+import Database from "better-sqlite3";
+import * as fs6 from "fs";
+import * as path9 from "path";
+var StoreError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "StoreError";
+    if (cause instanceof Error) this.cause = cause;
+  }
+};
+var MemoryStore = class {
+  constructor(dbPath, config2) {
+    this.config = config2;
+    fs6.mkdirSync(path9.dirname(dbPath), { recursive: true });
+    this.db = this.openDatabase(dbPath);
+  }
+  db;
+  _vecAvailable = false;
+  openDatabase(dbPath) {
+    try {
+      const db = new Database(dbPath);
+      db.pragma("journal_mode = WAL");
+      db.pragma("busy_timeout = 5000");
+      this.loadVecExtension(db);
+      this.createSchema(db);
+      return db;
+    } catch (err) {
+      console.error("[memory-store] DB open failed, recreating:", err);
+      try {
+        fs6.unlinkSync(dbPath);
+      } catch {
+      }
+      const db = new Database(dbPath);
+      db.pragma("journal_mode = WAL");
+      db.pragma("busy_timeout = 5000");
+      this.loadVecExtension(db);
+      this.createSchema(db);
+      return db;
+    }
+  }
+  loadVecExtension(db) {
+    try {
+      const sqliteVec = __require("sqlite-vec");
+      sqliteVec.load(db);
+      this._vecAvailable = true;
+    } catch (err) {
+      console.warn("[memory-store] sqlite-vec unavailable, degrading to FTS5-only:", err);
+      this._vecAvailable = false;
+    }
+  }
+  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(
+        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, content) VALUES (new.rowid, new.content);
+        END;
+
+      CREATE TRIGGER IF NOT EXISTS memory_chunks_ad
+        AFTER DELETE ON memory_chunks BEGIN
+          INSERT INTO memory_fts(memory_fts, rowid, content)
+            VALUES ('delete', old.rowid, 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;
+      }
+    }
+  }
+  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 (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    let insertVec = null;
+    if (this._vecAvailable) {
+      insertVec = this.db.prepare(`INSERT OR REPLACE INTO memory_vec (rowid, embedding) VALUES (?, ?)`);
+    }
+    const upsertAll = this.db.transaction(() => {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        try {
+          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()
+          );
+          if (insertVec && embeddings[i] && info.lastInsertRowid) {
+            const rowid = Number(info.lastInsertRowid);
+            const emb = embeddings[i];
+            const buf = Buffer.from(emb.buffer, emb.byteOffset, emb.byteLength);
+            insertVec.run(rowid, buf);
+          }
+        } catch (err) {
+          console.warn(`[memory-store] Failed to upsert chunk ${chunk.id}:`, err);
+        }
+      }
+    });
+    try {
+      upsertAll();
+    } catch (err) {
+      throw new StoreError("Full batch upsert failed", err);
+    }
+  }
+  hashesBySource(source) {
+    const rows = this.db.prepare(`SELECT id FROM memory_chunks WHERE source = ?`).all(source);
+    return new Set(rows.map((r) => r.id));
+  }
+  indexedSources() {
+    const rows = this.db.prepare(`SELECT DISTINCT source FROM memory_chunks`).all();
+    return rows.map((r) => r.source);
+  }
+  deleteBySource(source) {
+    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE source = ?`).all(source);
+    const deleteAll = this.db.transaction(() => {
+      if (this._vecAvailable && rows.length > 0) {
+        const placeholders = rows.map(() => "?").join(", ");
+        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${placeholders})`).run(...rows.map((r) => r.rowid));
+      }
+      this.db.prepare(`DELETE FROM memory_chunks WHERE source = ?`).run(source);
+    });
+    deleteAll();
+  }
+  deleteByIds(ids) {
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => "?").join(", ");
+    const rows = this.db.prepare(`SELECT rowid FROM memory_chunks WHERE id IN (${placeholders})`).all(...ids);
+    const deleteAll = this.db.transaction(() => {
+      if (this._vecAvailable && rows.length > 0) {
+        const rPlaceholders = rows.map(() => "?").join(", ");
+        this.db.prepare(`DELETE FROM memory_vec WHERE rowid IN (${rPlaceholders})`).run(...rows.map((r) => r.rowid));
+      }
+      this.db.prepare(`DELETE FROM memory_chunks WHERE id IN (${placeholders})`).run(...ids);
+    });
+    deleteAll();
+  }
+  searchDense(embedding, limit) {
+    if (!this._vecAvailable) return [];
+    try {
+      const buf = Buffer.from(embedding.buffer);
+      const rows = this.db.prepare(
+        `SELECT mc.id, mv.distance
+           FROM memory_vec mv
+           JOIN memory_chunks mc ON mc.rowid = mv.rowid
+           WHERE mv.embedding MATCH ? AND k = ?
+           ORDER BY mv.distance`
+      ).all(buf, limit);
+      return rows.map((r) => ({
+        id: r.id,
+        score: Math.max(0, 1 - r.distance)
+      }));
+    } catch (err) {
+      console.warn("[memory-store] Dense search failed:", err);
+      return [];
+    }
+  }
+  searchBm25(query, limit) {
+    if (!query.trim()) return [];
+    const ftsQuery = query.trim().split(/\s+/).map((t) => t.replace(/['"*^():\-]/g, " ").trim()).filter(Boolean).join(" OR ");
+    if (!ftsQuery) return [];
+    try {
+      const rows = this.db.prepare(
+        `SELECT mc.id, rank
+           FROM memory_fts
+           JOIN memory_chunks mc ON mc.rowid = memory_fts.rowid
+           WHERE memory_fts MATCH ?
+           ORDER BY rank
+           LIMIT ?`
+      ).all(ftsQuery, limit);
+      if (rows.length === 0) return [];
+      const ranks = rows.map((r) => r.rank);
+      const minRank = Math.min(...ranks);
+      const maxRank = Math.max(...ranks);
+      const range = maxRank - minRank;
+      return rows.map((r) => ({
+        id: r.id,
+        score: range > 0 ? (maxRank - r.rank) / range : 1
+      }));
+    } catch (err) {
+      console.warn("[memory-store] BM25 search failed:", err);
+      return [];
+    }
+  }
+  getChunksByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(", ");
+    const rows = this.db.prepare(
+      `SELECT id, source, heading, heading_level, content, line_start, line_end
+         FROM memory_chunks WHERE id IN (${placeholders})`
+    ).all(...ids);
+    return rows.map((r) => ({
+      id: r.id,
+      source: r.source,
+      heading: r.heading,
+      headingLevel: r.heading_level,
+      content: r.content,
+      lineStart: r.line_start,
+      lineEnd: r.line_end
+    }));
+  }
+  get vecAvailable() {
+    return this._vecAvailable;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/tools/memory.ts
+function registerMemoryToolHandlers(server2, indexer, store, config2) {
+  server2.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: external_exports.string().min(1).describe("Search query"),
+      top_k: external_exports.number().int().positive().optional().describe("Number of results to return")
+    },
+    async ({ query, top_k }) => {
+      try {
+        const results = await indexer.search(query, top_k ?? config2.topK);
+        if (results.length === 0) {
+          const degradedNote2 = !store.vecAvailable ? "\u26A0\uFE0F Vector search unavailable \u2014 showing keyword-only results.\n\n" : "";
+          return mcpText(`${degradedNote2}No memories found for query: "${query}"`);
+        }
+        const degradedNote = !store.vecAvailable ? "\u26A0\uFE0F Vector search unavailable \u2014 showing keyword-only results.\n\n" : "";
+        const formatted = results.map((r) => {
+          const displaySource = r.chunk.source.replace(/^compiled\//, "");
+          const content = r.contentSource === "fallback" ? `\u26A0\uFE0F Source file unavailable \u2014 showing matched chunk only:
+${r.chunk.content}` : r.chunk.content;
+          return `### ${displaySource} (score: ${r.score.toFixed(3)})
+${content}`;
+        }).join("\n\n---\n\n");
+        return mcpText(`${degradedNote}${formatted}`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return mcpText(`kit_memory_search failed: ${message}`);
+      }
+    }
+  );
+  server2.tool(
+    "kit_memory_save",
+    "Save content to wiki/raw for inclusion after the next /wiki compile.",
+    {
+      content: external_exports.string().min(1).describe("Content to save to memory")
+    },
+    async ({ content }) => {
+      try {
+        await indexer.save(content);
+        return mcpJson({
+          saved: true,
+          queued_for_compile: true,
+          message: "Saved to wiki/raw \u2014 will be indexed after next /wiki compile"
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return mcpJson({ saved: false, error: message });
+      }
+    }
+  );
+}
+function registerMemoryTools(server2, settings2, workspaceRoot2) {
+  if (settings2.memory?.enabled !== true) return null;
+  const config2 = resolveMemoryConfig(settings2, workspaceRoot2);
+  const store = new MemoryStore(path10.join(config2.wikiDir, "index.db"), config2);
+  const embedder = new Embedder(config2.embeddingModel);
+  const indexer = new MemoryIndexer(store, embedder, config2);
+  registerMemoryToolHandlers(server2, indexer, store, config2);
+  return indexer;
+}
+
 // src/kit-server.ts
 var server = new McpServer({
   name: "kit-agents",
@@ -21750,5 +22499,11 @@ var server = new McpServer({
 registerIntegrationTools(server);
 registerCoreTools(server);
 registerAgentTools(server);
+var workspaceRoot = getWorkspaceRoot();
+var settings = loadProjectSettings(workspaceRoot);
+var memoryIndexer = registerMemoryTools(server, settings, workspaceRoot);
 var transport = new StdioServerTransport();
 await server.connect(transport);
+if (memoryIndexer) {
+  void memoryIndexer.startupIndex();
+}