fourmis-agents-sdk 0.2.6 → 0.3.1

package/dist/index.js

@@ -501,7 +501,8 @@ async function* agentLoop(prompt, options) {
     hooks,
     mcpClient,
     previousMessages,
-    sessionLogger
+    sessionLogger,
+    nativeMemoryTool
   } = options;
   const startTime = Date.now();
   let apiTimeMs = 0;
@@ -555,13 +556,15 @@ async function* agentLoop(prompt, options) {
     let assistantTextParts = [];
     let toolCalls = [];
     let turnUsage = emptyTokenUsage();
+    const nativeTools = nativeMemoryTool ? [nativeMemoryTool.definition] : undefined;
     try {
       const chunks = provider.chat({
         model,
         messages,
         tools: toolDefs.length > 0 ? toolDefs : undefined,
         systemPrompt,
-        signal
+        signal,
+        nativeTools
       });
       for await (const chunk of chunks) {
         switch (chunk.type) {
@@ -719,13 +722,24 @@ async function* agentLoop(prompt, options) {
         input: toolInput,
         uuid: uuid()
       };
-      const toolCtx = {
-        cwd,
-        signal,
-        sessionId,
-        env
-      };
-      const result = await tools.execute(call.name, toolInput, toolCtx);
+      let result;
+      if (call.name === "memory" && nativeMemoryTool) {
+        try {
+          const content = await nativeMemoryTool.execute(toolInput);
+          result = { content, isError: content.startsWith("Error:") };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          result = { content: `Error: ${message}`, isError: true };
+        }
+      } else {
+        const toolCtx = {
+          cwd,
+          signal,
+          sessionId,
+          env
+        };
+        result = await tools.execute(call.name, toolInput, toolCtx);
+      }
       if (debug) {
         console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
       }
@@ -1040,15 +1054,29 @@ class AnthropicAdapter {
     } else if (request.systemPrompt) {
       params.system = request.systemPrompt;
     }
+    const allTools = [];
     if (tools && tools.length > 0) {
-      params.tools = tools;
+      allTools.push(...tools);
+    }
+    if (request.nativeTools && request.nativeTools.length > 0) {
+      allTools.push(...request.nativeTools);
+    }
+    if (allTools.length > 0) {
+      params.tools = allTools;
     }
     if (request.temperature !== undefined) {
       params.temperature = request.temperature;
     }
-    const stream = this.client.messages.stream(params, {
+    const hasMemoryTool = request.nativeTools?.some((t) => t.type === "memory_20250818");
+    const requestOptions = {
       signal: request.signal
-    });
+    };
+    if (hasMemoryTool) {
+      requestOptions.headers = {
+        "anthropic-beta": "context-management-2025-06-27"
+      };
+    }
+    const stream = this.client.messages.stream(params, requestOptions);
     const toolInputBuffers = new Map;
     for await (const event of stream) {
       switch (event.type) {
@@ -2888,9 +2916,277 @@ class SettingsManager {
   }
 }
 
+// src/skills/frontmatter.ts
+import { parse } from "yaml";
+function normalizeNewlines(value) {
+  return value.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function extractFrontmatter(content) {
+  const normalized = normalizeNewlines(content);
+  if (!normalized.startsWith("---")) {
+    return { yamlString: null, body: normalized };
+  }
+  const endIndex = normalized.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return { yamlString: null, body: normalized };
+  }
+  return {
+    yamlString: normalized.slice(4, endIndex),
+    body: normalized.slice(endIndex + 4).trim()
+  };
+}
+function parseFrontmatter(content) {
+  const { yamlString, body } = extractFrontmatter(content);
+  if (!yamlString) {
+    return { frontmatter: {}, body };
+  }
+  const parsed = parse(yamlString);
+  return { frontmatter: parsed ?? {}, body };
+}
+function stripFrontmatter(content) {
+  return parseFrontmatter(content).body;
+}
+
+// src/skills/skills.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, realpathSync, statSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename, dirname as dirname3, isAbsolute, join as join4, resolve } from "path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var CONFIG_DIR_NAME = ".claude";
+function shouldIgnore(name) {
+  return name.startsWith(".") || name === "node_modules";
+}
+function validateName(name, parentDirName) {
+  const errors = [];
+  if (name !== parentDirName) {
+    errors.push(`name "${name}" does not match parent directory "${parentDirName}"`);
+  }
+  if (name.length > MAX_NAME_LENGTH) {
+    errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push(`name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)`);
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    errors.push(`name must not start or end with a hyphen`);
+  }
+  if (name.includes("--")) {
+    errors.push(`name must not contain consecutive hyphens`);
+  }
+  return errors;
+}
+function validateDescription(description) {
+  const errors = [];
+  if (!description || description.trim() === "") {
+    errors.push("description is required");
+  } else if (description.length > MAX_DESCRIPTION_LENGTH) {
+    errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+  }
+  return errors;
+}
+function loadSkillsFromDir(options) {
+  return loadSkillsFromDirInternal(options.dir, options.source, true);
+}
+function loadSkillsFromDirInternal(dir, source, includeRootFiles) {
+  const skills = [];
+  const diagnostics = [];
+  if (!existsSync4(dir)) {
+    return { skills, diagnostics };
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (shouldIgnore(entry.name)) {
+        continue;
+      }
+      const fullPath = join4(dir, entry.name);
+      let isDirectory = entry.isDirectory();
+      let isFile = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          const stats = statSync(fullPath);
+          isDirectory = stats.isDirectory();
+          isFile = stats.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDirectory) {
+        const subResult = loadSkillsFromDirInternal(fullPath, source, false);
+        skills.push(...subResult.skills);
+        diagnostics.push(...subResult.diagnostics);
+        continue;
+      }
+      if (!isFile)
+        continue;
+      const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+      const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+      if (!isRootMd && !isSkillMd)
+        continue;
+      const result = loadSkillFromFile(fullPath, source);
+      if (result.skill) {
+        skills.push(result.skill);
+      }
+      diagnostics.push(...result.diagnostics);
+    }
+  } catch {}
+  return { skills, diagnostics };
+}
+function loadSkillFromFile(filePath, source) {
+  const diagnostics = [];
+  try {
+    const rawContent = readFileSync4(filePath, "utf-8");
+    const { frontmatter } = parseFrontmatter(rawContent);
+    const skillDir = dirname3(filePath);
+    const parentDirName = basename(skillDir);
+    const descErrors = validateDescription(frontmatter.description);
+    for (const error of descErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const name = frontmatter.name || parentDirName;
+    const nameErrors = validateName(name, parentDirName);
+    for (const error of nameErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    if (!frontmatter.description || frontmatter.description.trim() === "") {
+      return { skill: null, diagnostics };
+    }
+    return {
+      skill: {
+        name,
+        description: frontmatter.description,
+        filePath,
+        baseDir: skillDir,
+        source,
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true
+      },
+      diagnostics
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "failed to parse skill file";
+    diagnostics.push({ type: "warning", message, path: filePath });
+    return { skill: null, diagnostics };
+  }
+}
+function normalizePath(input) {
+  const trimmed = input.trim();
+  if (trimmed === "~")
+    return homedir4();
+  if (trimmed.startsWith("~/"))
+    return join4(homedir4(), trimmed.slice(2));
+  if (trimmed.startsWith("~"))
+    return join4(homedir4(), trimmed.slice(1));
+  return trimmed;
+}
+function resolveSkillPath(p, cwd) {
+  const normalized = normalizePath(p);
+  return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
+}
+function loadSkills(options = {}) {
+  const { cwd = process.cwd(), skillPaths = [], includeDefaults = true } = options;
+  const skillMap = new Map;
+  const realPathSet = new Set;
+  const allDiagnostics = [];
+  const collisionDiagnostics = [];
+  function addSkills(result) {
+    allDiagnostics.push(...result.diagnostics);
+    for (const skill of result.skills) {
+      let realPath;
+      try {
+        realPath = realpathSync(skill.filePath);
+      } catch {
+        realPath = skill.filePath;
+      }
+      if (realPathSet.has(realPath))
+        continue;
+      const existing = skillMap.get(skill.name);
+      if (existing) {
+        collisionDiagnostics.push({
+          type: "collision",
+          message: `name "${skill.name}" collision`,
+          path: skill.filePath,
+          collision: {
+            resourceType: "skill",
+            name: skill.name,
+            winnerPath: existing.filePath,
+            loserPath: skill.filePath
+          }
+        });
+      } else {
+        skillMap.set(skill.name, skill);
+        realPathSet.add(realPath);
+      }
+    }
+  }
+  if (includeDefaults) {
+    const userSkillsDir = join4(homedir4(), CONFIG_DIR_NAME, "skills");
+    const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
+    addSkills(loadSkillsFromDirInternal(userSkillsDir, "user", true));
+    addSkills(loadSkillsFromDirInternal(projectSkillsDir, "project", true));
+  }
+  for (const rawPath of skillPaths) {
+    const resolvedPath = resolveSkillPath(rawPath, cwd);
+    if (!existsSync4(resolvedPath)) {
+      allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
+      continue;
+    }
+    try {
+      const stats = statSync(resolvedPath);
+      if (stats.isDirectory()) {
+        addSkills(loadSkillsFromDirInternal(resolvedPath, "path", true));
+      } else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+        const result = loadSkillFromFile(resolvedPath, "path");
+        if (result.skill) {
+          addSkills({ skills: [result.skill], diagnostics: result.diagnostics });
+        } else {
+          allDiagnostics.push(...result.diagnostics);
+        }
+      } else {
+        allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "failed to read skill path";
+      allDiagnostics.push({ type: "warning", message, path: resolvedPath });
+    }
+  }
+  return {
+    skills: Array.from(skillMap.values()),
+    diagnostics: [...allDiagnostics, ...collisionDiagnostics]
+  };
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatSkillsForPrompt(skills) {
+  const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+  if (visibleSkills.length === 0) {
+    return "";
+  }
+  const lines = [
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of visibleSkills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join(`
+`);
+}
 // src/utils/system-prompt.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
 var CORE_IDENTITY = `You are an AI coding agent. You help users with software engineering tasks by reading, writing, and modifying code. You have access to tools that let you interact with the filesystem and execute commands.
 
 You are highly capable and can help users complete complex tasks that would otherwise be too difficult or time-consuming.`;
@@ -2961,6 +3257,14 @@ Working directory: ${context.cwd}`);
 ${instructions}`);
     }
   }
+  if (context.skills && context.skills.length > 0) {
+    const skillsPrompt = formatSkillsForPrompt(context.skills);
+    if (skillsPrompt) {
+      sections.push(`# Skills
+
+${skillsPrompt}`);
+    }
+  }
   if (context.customPrompt) {
     sections.push(context.customPrompt);
   }
@@ -2971,7 +3275,7 @@ ${instructions}`);
 function readProjectInstructions(cwd) {
   for (const name of ["CLAUDE.md", "AGENTS.md"]) {
     try {
-      const content = readFileSync4(join4(cwd, name), "utf-8").trim();
+      const content = readFileSync5(join5(cwd, name), "utf-8").trim();
       if (content)
         return content;
     } catch {}
@@ -3462,7 +3766,7 @@ class TaskManager {
     if (!block) {
       return `Task "${id}" is still running.`;
     }
-    const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    const timeoutPromise = new Promise((resolve2) => setTimeout(resolve2, timeoutMs));
     await Promise.race([task.promise, timeoutPromise]);
     if (task.status === "running") {
       return `Task "${id}" is still running (timed out after ${timeoutMs}ms).`;
@@ -3484,21 +3788,21 @@ class TaskManager {
 }
 
 // src/utils/session-store.ts
-import { readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync3, readdirSync, statSync } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir4 } from "os";
+import { readFileSync as readFileSync6, appendFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 function sanitizeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
 }
 function sessionsDir(cwd) {
-  return join5(homedir4(), ".claude", "projects", sanitizeCwd(cwd));
+  return join6(homedir5(), ".claude", "projects", sanitizeCwd(cwd));
 }
 function ensureDir(dir) {
   mkdirSync3(dir, { recursive: true });
 }
 function logMessage(dir, sessionId, entry) {
   ensureDir(dir);
-  const filePath = join5(dir, `${sessionId}.jsonl`);
+  const filePath = join6(dir, `${sessionId}.jsonl`);
   appendFileSync(filePath, JSON.stringify(entry) + `
 `);
 }
@@ -3535,10 +3839,10 @@ function createSessionLogger(cwd, sessionId, model) {
 function findLatestSession(cwd) {
   const dir = sessionsDir(cwd);
   try {
-    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
-      const filePath = join5(dir, f);
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const filePath = join6(dir, f);
       try {
-        return { name: f, mtime: statSync(filePath).mtimeMs };
+        return { name: f, mtime: statSync2(filePath).mtimeMs };
       } catch {
         return null;
       }
@@ -3552,10 +3856,10 @@ function findLatestSession(cwd) {
 }
 function loadSessionMessages(cwd, sessionId) {
   const dir = sessionsDir(cwd);
-  const filePath = join5(dir, `${sessionId}.jsonl`);
+  const filePath = join6(dir, `${sessionId}.jsonl`);
   let lines;
   try {
-    lines = readFileSync5(filePath, "utf-8").trim().split(`
+    lines = readFileSync6(filePath, "utf-8").trim().split(`
 `).filter(Boolean);
   } catch {
     return [];
@@ -3586,6 +3890,307 @@ function loadSessionMessages(cwd, sessionId) {
   return messages;
 }
 
+// src/memory/memory-handler.ts
+import { readdir, stat, readFile, writeFile, rm, rename, mkdir as mkdir2 } from "fs/promises";
+import { join as join7, resolve as resolve2, relative as relative2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+function createMemoryHandler(memoryDir) {
+  const absMemoryDir = resolve2(memoryDir);
+  function resolvePath2(logicalPath) {
+    let cleaned = logicalPath;
+    if (cleaned.startsWith("/memories")) {
+      cleaned = cleaned.slice("/memories".length);
+    }
+    if (cleaned.startsWith("/")) {
+      cleaned = cleaned.slice(1);
+    }
+    if (cleaned.includes("..") || cleaned.includes("%2e") || cleaned.includes("%2E")) {
+      throw new Error(`Path traversal detected: ${logicalPath}`);
+    }
+    const absPath = cleaned === "" ? absMemoryDir : resolve2(absMemoryDir, cleaned);
+    const rel = relative2(absMemoryDir, absPath);
+    if (rel.startsWith("..") || resolve2(absPath) !== absPath && !absPath.startsWith(absMemoryDir)) {
+      throw new Error(`Path traversal detected: ${logicalPath}`);
+    }
+    return absPath;
+  }
+  function toLogicalPath(absPath) {
+    const rel = relative2(absMemoryDir, absPath);
+    return rel === "" ? "/memories" : `/memories/${rel}`;
+  }
+  function formatSize(bytes) {
+    if (bytes < 1024)
+      return `${bytes}`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)}K`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+  }
+  async function listDir(dirPath, depth = 0) {
+    const lines = [];
+    const dirStat = await stat(dirPath);
+    if (depth === 0) {
+      lines.push(`${formatSize(dirStat.size)}	${toLogicalPath(dirPath)}`);
+    }
+    if (depth >= 2)
+      return lines;
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
+        const entryPath = join7(dirPath, entry.name);
+        const entryStat = await stat(entryPath);
+        lines.push(`${formatSize(entryStat.size)}	${toLogicalPath(entryPath)}`);
+        if (entry.isDirectory()) {
+          const subLines = await listDir(entryPath, depth + 1);
+          lines.push(...subLines.slice(depth === 0 ? 0 : 0));
+        }
+      }
+    } catch {}
+    return lines;
+  }
+  function formatFileContent(content, viewRange) {
+    const lines = content.split(`
+`);
+    if (lines.length > 999999) {
+      throw new Error(`File exceeds maximum line limit of 999,999 lines.`);
+    }
+    let start = 0;
+    let end = lines.length;
+    if (viewRange && viewRange.length >= 2) {
+      start = Math.max(0, viewRange[0] - 1);
+      end = Math.min(lines.length, viewRange[1]);
+    }
+    const formatted = [];
+    for (let i = start;i < end; i++) {
+      const lineNum = String(i + 1).padStart(6, " ");
+      formatted.push(`${lineNum}	${lines[i]}`);
+    }
+    return formatted.join(`
+`);
+  }
+  async function handleView(cmd) {
+    const absPath = resolvePath2(cmd.path);
+    if (!existsSync5(absPath)) {
+      return `The path ${cmd.path} does not exist. Please provide a valid path.`;
+    }
+    const s = await stat(absPath);
+    if (s.isDirectory()) {
+      const lines = await listDir(absPath);
+      return `Here're the files and directories up to 2 levels deep in ${cmd.path}, excluding hidden items and node_modules:
+${lines.join(`
+`)}`;
+    }
+    const content = await readFile(absPath, "utf-8");
+    const formatted = formatFileContent(content, cmd.view_range);
+    return `Here's the content of ${cmd.path} with line numbers:
+${formatted}`;
+  }
+  async function handleCreate(cmd) {
+    const absPath = resolvePath2(cmd.path);
+    if (existsSync5(absPath)) {
+      return `Error: File ${cmd.path} already exists`;
+    }
+    const parentDir = resolve2(absPath, "..");
+    await mkdir2(parentDir, { recursive: true });
+    await writeFile(absPath, cmd.file_text, "utf-8");
+    return `File created successfully at: ${cmd.path}`;
+  }
+  async function handleStrReplace(cmd) {
+    const absPath = resolvePath2(cmd.path);
+    if (!existsSync5(absPath)) {
+      return `Error: The path ${cmd.path} does not exist. Please provide a valid path.`;
+    }
+    const s = await stat(absPath);
+    if (s.isDirectory()) {
+      return `Error: The path ${cmd.path} does not exist. Please provide a valid path.`;
+    }
+    const content = await readFile(absPath, "utf-8");
+    const lines = content.split(`
+`);
+    const matchingLines = [];
+    let searchPos = 0;
+    let occurrences = 0;
+    while (true) {
+      const idx = content.indexOf(cmd.old_str, searchPos);
+      if (idx === -1)
+        break;
+      occurrences++;
+      const lineNum = content.substring(0, idx).split(`
+`).length;
+      matchingLines.push(lineNum);
+      searchPos = idx + cmd.old_str.length;
+    }
+    if (occurrences === 0) {
+      return `No replacement was performed, old_str \`${cmd.old_str}\` did not appear verbatim in ${cmd.path}.`;
+    }
+    if (occurrences > 1) {
+      return `No replacement was performed. Multiple occurrences of old_str \`${cmd.old_str}\` in lines: ${matchingLines.join(", ")}. Please ensure it is unique`;
+    }
+    const newContent = content.replace(cmd.old_str, cmd.new_str);
+    await writeFile(absPath, newContent, "utf-8");
+    const newLines = newContent.split(`
+`);
+    const replaceLine = matchingLines[0];
+    const snippetStart = Math.max(0, replaceLine - 3);
+    const snippetEnd = Math.min(newLines.length, replaceLine + 3);
+    const snippet = newLines.slice(snippetStart, snippetEnd).map((line, i) => `${String(snippetStart + i + 1).padStart(6, " ")}	${line}`).join(`
+`);
+    return `The memory file has been edited.
+${snippet}`;
+  }
+  async function handleInsert(cmd) {
+    const absPath = resolvePath2(cmd.path);
+    if (!existsSync5(absPath)) {
+      return `Error: The path ${cmd.path} does not exist`;
+    }
+    const s = await stat(absPath);
+    if (s.isDirectory()) {
+      return `Error: The path ${cmd.path} does not exist`;
+    }
+    const content = await readFile(absPath, "utf-8");
+    const lines = content.split(`
+`);
+    if (cmd.insert_line < 0 || cmd.insert_line > lines.length) {
+      return `Error: Invalid \`insert_line\` parameter: ${cmd.insert_line}. It should be within the range of lines of the file: [0, ${lines.length}]`;
+    }
+    const insertLines = cmd.insert_text.split(`
+`);
+    lines.splice(cmd.insert_line, 0, ...insertLines);
+    await writeFile(absPath, lines.join(`
+`), "utf-8");
+    return `The file ${cmd.path} has been edited.`;
+  }
+  async function handleDelete(cmd) {
+    const absPath = resolvePath2(cmd.path);
+    if (!existsSync5(absPath)) {
+      return `Error: The path ${cmd.path} does not exist`;
+    }
+    await rm(absPath, { recursive: true, force: true });
+    return `Successfully deleted ${cmd.path}`;
+  }
+  async function handleRename(cmd) {
+    const oldAbs = resolvePath2(cmd.old_path);
+    const newAbs = resolvePath2(cmd.new_path);
+    if (!existsSync5(oldAbs)) {
+      return `Error: The path ${cmd.old_path} does not exist`;
+    }
+    if (existsSync5(newAbs)) {
+      return `Error: The destination ${cmd.new_path} already exists`;
+    }
+    const parentDir = resolve2(newAbs, "..");
+    await mkdir2(parentDir, { recursive: true });
+    await rename(oldAbs, newAbs);
+    return `Successfully renamed ${cmd.old_path} to ${cmd.new_path}`;
+  }
+  async function execute(cmd) {
+    if (!existsSync5(absMemoryDir)) {
+      await mkdir2(absMemoryDir, { recursive: true });
+    }
+    switch (cmd.command) {
+      case "view":
+        return handleView(cmd);
+      case "create":
+        return handleCreate(cmd);
+      case "str_replace":
+        return handleStrReplace(cmd);
+      case "insert":
+        return handleInsert(cmd);
+      case "delete":
+        return handleDelete(cmd);
+      case "rename":
+        return handleRename(cmd);
+      default:
+        return `Error: Unknown command: ${cmd.command}`;
+    }
+  }
+  return { execute, resolvePath: resolvePath2, toLogicalPath };
+}
+// src/memory/index.ts
+function createNativeMemoryTool(config) {
+  const handler = createMemoryHandler(config.path);
+  return {
+    definition: { type: "memory_20250818", name: "memory" },
+    execute: (cmd) => handler.execute(cmd)
+  };
+}
+function createMemoryTool(config) {
+  const handler = createMemoryHandler(config.path);
+  return {
+    name: "memory",
+    description: `Manage persistent memory files. Supports 6 commands:
+` + `- view: Show directory listing or file contents (path, optional view_range)
+` + `- create: Create a new file (path, file_text)
+` + `- str_replace: Replace text in a file (path, old_str, new_str)
+` + `- insert: Insert text at a line number (path, insert_line, insert_text)
+` + `- delete: Delete a file or directory (path)
+` + `- rename: Rename/move a file or directory (old_path, new_path)
+
+` + `All paths should start with /memories/. Example: /memories/notes.txt
+
+` + "IMPORTANT: Always view your memory directory before starting any task.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          enum: ["view", "create", "str_replace", "insert", "delete", "rename"],
+          description: "The memory operation to perform"
+        },
+        path: {
+          type: "string",
+          description: "Path to the file or directory (starts with /memories/)"
+        },
+        file_text: {
+          type: "string",
+          description: "Content for the 'create' command"
+        },
+        old_str: {
+          type: "string",
+          description: "Text to find for 'str_replace' command"
+        },
+        new_str: {
+          type: "string",
+          description: "Replacement text for 'str_replace' command"
+        },
+        insert_line: {
+          type: "number",
+          description: "Line number for 'insert' command"
+        },
+        insert_text: {
+          type: "string",
+          description: "Text to insert for 'insert' command"
+        },
+        old_path: {
+          type: "string",
+          description: "Source path for 'rename' command"
+        },
+        new_path: {
+          type: "string",
+          description: "Destination path for 'rename' command"
+        },
+        view_range: {
+          type: "array",
+          items: { type: "number" },
+          description: "Optional [start, end] line range for 'view' command"
+        }
+      },
+      required: ["command"]
+    },
+    async execute(input) {
+      try {
+        const cmd = input;
+        const result = await handler.execute(cmd);
+        const isError = result.startsWith("Error:");
+        return { content: result, isError };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error: ${message}`, isError: true };
+      }
+    }
+  };
+}
+
 // src/api.ts
 var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
 var DEFAULT_MAX_TURNS = 10;
@@ -3600,10 +4205,25 @@ function query(params) {
   const model = options.model ?? DEFAULT_MODEL;
   const toolNames = resolveToolNames(options.tools);
   const registry = buildToolRegistry(toolNames, undefined, options.disallowedTools);
+  let skills = [];
+  {
+    const skillsResult = loadSkills({
+      cwd: options.cwd,
+      skillPaths: options.skillPaths,
+      includeDefaults: options.includeDefaultSkills !== false
+    });
+    skills = skillsResult.skills;
+    if (options.debug && skillsResult.diagnostics.length > 0) {
+      for (const d of skillsResult.diagnostics) {
+        console.warn(`[skills] ${d.type}: ${d.message} (${d.path})`);
+      }
+    }
+  }
   const systemPrompt = options.systemPrompt ?? buildSystemPrompt({
     tools: registry.list(),
     cwd: options.cwd,
-    customPrompt: options.appendSystemPrompt
+    customPrompt: options.appendSystemPrompt,
+    skills
   });
   let settingsManager;
   let mergedPermissions = options.permissions;
@@ -3682,6 +4302,15 @@ function query(params) {
     registry.register(createTaskOutputTool(taskManager));
     registry.register(createTaskStopTool(taskManager));
   }
+  let nativeMemoryTool;
+  if (options.memoryPath) {
+    const memoryConfig = { path: options.memoryPath };
+    if (providerName === "anthropic") {
+      nativeMemoryTool = createNativeMemoryTool(memoryConfig);
+    } else {
+      registry.register(createMemoryTool(memoryConfig));
+    }
+  }
   const generator = agentLoop(prompt, {
     provider,
     model,
@@ -3699,7 +4328,8 @@ function query(params) {
     hooks: hookManager,
     mcpClient,
     previousMessages,
-    sessionLogger
+    sessionLogger,
+    nativeMemoryTool
   });
   return createQuery(generator, abortController);
 }
@@ -3729,10 +4359,18 @@ function createMcpServer(opts) {
   };
 }
 export {
+  stripFrontmatter,
   registerProvider,
   query,
+  parseFrontmatter,
   tool as mcpTool,
+  loadSkillsFromDir,
+  loadSkills,
   getProvider,
+  formatSkillsForPrompt,
+  createNativeMemoryTool,
+  createMemoryTool,
+  createMemoryHandler,
   createMcpServer,
   WriteTool,
   ToolRegistry,