@elizaos/plugin-scratchpad 2.0.0-alpha

package/dist/cjs/index.node.cjs

@@ -0,0 +1,1121 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// index.node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  scratchpadWriteAction: () => scratchpadWriteAction,
+  scratchpadSearchAction: () => scratchpadSearchAction,
+  scratchpadReadAction: () => scratchpadReadAction,
+  scratchpadProvider: () => scratchpadProvider,
+  scratchpadPlugin: () => scratchpadPlugin,
+  scratchpadListAction: () => scratchpadListAction,
+  scratchpadDeleteAction: () => scratchpadDeleteAction,
+  scratchpadAppendAction: () => scratchpadAppendAction,
+  default: () => typescript_default,
+  createScratchpadService: () => createScratchpadService,
+  ScratchpadService: () => ScratchpadService
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// index.ts
+var import_core9 = require("@elizaos/core");
+
+// actions/append.ts
+var import_core2 = require("@elizaos/core");
+
+// generated/specs/specs.ts
+var actionSpecs = {
+  SCRATCHPAD_WRITE: {
+    name: "SCRATCHPAD_WRITE",
+    description: "Write a new note or memory to the scratchpad. Use this to save information for later retrieval.",
+    similes: [
+      "SAVE_NOTE",
+      "CREATE_NOTE",
+      "WRITE_NOTE",
+      "REMEMBER_THIS",
+      "SAVE_MEMORY",
+      "JOT_DOWN",
+      "NOTE_THIS"
+    ],
+    examples: [
+      [
+        {
+          role: "user",
+          content: "Please save a note about the meeting tomorrow at 3pm with John about the marketing strategy."
+        },
+        {
+          role: "assistant",
+          content: "I've saved a note about your meeting. Title: 'Meeting with John - Marketing Strategy'. You can retrieve it later."
+        }
+      ],
+      [
+        {
+          role: "user",
+          content: "Remember that the API key for the service is stored in the .env file."
+        },
+        {
+          role: "assistant",
+          content: "I've noted that the API key is stored in the .env file. I'll remember this for future reference."
+        }
+      ]
+    ]
+  },
+  SCRATCHPAD_READ: {
+    name: "SCRATCHPAD_READ",
+    description: "Read the content of a specific scratchpad entry. Use after searching to retrieve full details.",
+    similes: ["GET_NOTE", "READ_NOTE", "RETRIEVE_NOTE", "GET_MEMORY", "FETCH_NOTE", "OPEN_NOTE"],
+    examples: [
+      [
+        {
+          role: "user",
+          content: "Can you show me the note about the marketing meeting?"
+        },
+        {
+          role: "assistant",
+          content: "Here's the note 'Meeting with John - Marketing Strategy': Meeting scheduled for tomorrow at 3pm..."
+        }
+      ]
+    ]
+  },
+  SCRATCHPAD_SEARCH: {
+    name: "SCRATCHPAD_SEARCH",
+    description: "Search through scratchpad entries for relevant information. Returns matching snippets with relevance scores.",
+    similes: [
+      "FIND_NOTE",
+      "SEARCH_NOTES",
+      "LOOKUP_MEMORY",
+      "FIND_MEMORY",
+      "SEARCH_MEMORY",
+      "RECALL"
+    ],
+    examples: [
+      [
+        {
+          role: "user",
+          content: "What notes do I have about marketing?"
+        },
+        {
+          role: "assistant",
+          content: "I found 2 scratchpad entries mentioning marketing: 1) 'Meeting with John - Marketing Strategy' (score: 0.85)..."
+        }
+      ]
+    ]
+  },
+  SCRATCHPAD_LIST: {
+    name: "SCRATCHPAD_LIST",
+    description: "List all scratchpad entries with their titles and modification dates.",
+    similes: ["SHOW_NOTES", "LIST_NOTES", "ALL_NOTES", "MY_NOTES", "SHOW_MEMORIES"],
+    examples: [
+      [
+        {
+          role: "user",
+          content: "Show me all my saved notes."
+        },
+        {
+          role: "assistant",
+          content: "You have 5 scratchpad entries: 1) Meeting notes (modified today), 2) API documentation (modified yesterday)..."
+        }
+      ]
+    ]
+  },
+  SCRATCHPAD_DELETE: {
+    name: "SCRATCHPAD_DELETE",
+    description: "Delete a scratchpad entry by its ID.",
+    similes: ["REMOVE_NOTE", "DELETE_NOTE", "FORGET_NOTE", "ERASE_NOTE", "REMOVE_MEMORY"],
+    examples: [
+      [
+        {
+          role: "user",
+          content: "Delete the note about the old meeting."
+        },
+        {
+          role: "assistant",
+          content: "I've deleted the scratchpad entry 'old-meeting'. The note has been removed."
+        }
+      ]
+    ]
+  },
+  SCRATCHPAD_APPEND: {
+    name: "SCRATCHPAD_APPEND",
+    description: "Append additional content to an existing scratchpad entry.",
+    similes: ["ADD_TO_NOTE", "UPDATE_NOTE", "APPEND_NOTE", "EXTEND_NOTE", "ADD_MORE"],
+    examples: [
+      [
+        {
+          role: "user",
+          content: "Add to the meeting notes that we decided on a $50k budget."
+        },
+        {
+          role: "assistant",
+          content: "I've appended the budget decision to the meeting notes. The note now includes the $50k budget information."
+        }
+      ]
+    ]
+  }
+};
+function requireActionSpec(name) {
+  const spec = actionSpecs[name];
+  if (!spec) {
+    throw new Error(`Action spec not found: ${name}`);
+  }
+  return spec;
+}
+
+// services/scratchpadService.ts
+var fs = __toESM(require("node:fs/promises"));
+var os = __toESM(require("node:os"));
+var path = __toESM(require("node:path"));
+var import_core = require("@elizaos/core");
+var DEFAULT_CONFIG = {
+  basePath: path.join(os.homedir(), ".eliza", "scratchpad"),
+  maxFileSize: 1024 * 1024,
+  allowedExtensions: [".md", ".txt"]
+};
+
+class ScratchpadService {
+  config;
+  constructor(_runtime, config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  async ensureDirectory() {
+    try {
+      await fs.mkdir(this.config.basePath, { recursive: true });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core.logger.error("[ScratchpadService] Failed to create directory:", errorMsg);
+      throw error;
+    }
+  }
+  sanitizeFilename(title) {
+    return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").substring(0, 100);
+  }
+  getFilePath(id) {
+    const filename = id.endsWith(".md") ? id : `${id}.md`;
+    return path.join(this.config.basePath, filename);
+  }
+  getEntryId(filename) {
+    return path.basename(filename, path.extname(filename));
+  }
+  async write(title, content, options = {}) {
+    await this.ensureDirectory();
+    const id = this.sanitizeFilename(title);
+    const filePath = this.getFilePath(id);
+    const now = new Date;
+    let finalContent;
+    let createdAt = now;
+    const exists = await this.exists(id);
+    if (exists && options.append) {
+      const existing = await this.read(id);
+      finalContent = `${existing.content}
+
+---
+
+${content}`;
+      createdAt = existing.createdAt;
+    } else {
+      const tagsLine = options.tags?.length ? `tags: [${options.tags.join(", ")}]` : "";
+      const frontmatter = [
+        "---",
+        `title: "${title}"`,
+        `created: ${now.toISOString()}`,
+        `modified: ${now.toISOString()}`,
+        tagsLine,
+        "---",
+        ""
+      ].filter(Boolean).join(`
+`);
+      finalContent = `${frontmatter}
+${content}`;
+    }
+    if (Buffer.byteLength(finalContent, "utf8") > (this.config.maxFileSize ?? 1024 * 1024)) {
+      throw new Error(`Content exceeds maximum file size of ${this.config.maxFileSize} bytes`);
+    }
+    await fs.writeFile(filePath, finalContent, "utf8");
+    import_core.logger.info(`[ScratchpadService] Wrote entry: ${id}`);
+    return {
+      id,
+      path: filePath,
+      title,
+      content: finalContent,
+      createdAt,
+      modifiedAt: now,
+      tags: options.tags
+    };
+  }
+  async read(id, options = {}) {
+    const filePath = this.getFilePath(id);
+    try {
+      const stat2 = await fs.stat(filePath);
+      let content = await fs.readFile(filePath, "utf8");
+      if (options.from !== undefined || options.lines !== undefined) {
+        const lines = content.split(`
+`);
+        const fromLine = Math.max(1, options.from ?? 1) - 1;
+        const numLines = options.lines ?? lines.length - fromLine;
+        content = lines.slice(fromLine, fromLine + numLines).join(`
+`);
+      }
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      let title = id;
+      let tags = [];
+      let createdAt = stat2.birthtime;
+      if (frontmatterMatch) {
+        const frontmatter = frontmatterMatch[1];
+        const titleMatch = frontmatter.match(/title:\s*"?([^"\n]+)"?/);
+        const tagsMatch = frontmatter.match(/tags:\s*\[([^\]]+)\]/);
+        const createdMatch = frontmatter.match(/created:\s*(.+)/);
+        if (titleMatch)
+          title = titleMatch[1];
+        if (tagsMatch)
+          tags = tagsMatch[1].split(",").map((t) => t.trim());
+        if (createdMatch)
+          createdAt = new Date(createdMatch[1]);
+      }
+      return {
+        id,
+        path: filePath,
+        title,
+        content,
+        createdAt,
+        modifiedAt: stat2.mtime,
+        tags
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Scratchpad entry not found: ${id}`);
+      }
+      throw error;
+    }
+  }
+  async exists(id) {
+    const filePath = this.getFilePath(id);
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list() {
+    await this.ensureDirectory();
+    try {
+      const files = await fs.readdir(this.config.basePath);
+      const entries = [];
+      for (const file of files) {
+        const ext = path.extname(file);
+        if (!this.config.allowedExtensions?.includes(ext))
+          continue;
+        try {
+          const id = this.getEntryId(file);
+          const entry = await this.read(id);
+          entries.push(entry);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          import_core.logger.warn(`[ScratchpadService] Failed to read entry ${file}:`, errorMsg);
+        }
+      }
+      return entries.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core.logger.error("[ScratchpadService] Failed to list entries:", errorMsg);
+      return [];
+    }
+  }
+  async search(query, options = {}) {
+    const entries = await this.list();
+    const results = [];
+    const maxResults = options.maxResults ?? 10;
+    const minScore = options.minScore ?? 0.1;
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+    for (const entry of entries) {
+      const lines = entry.content.split(`
+`);
+      const contentLower = entry.content.toLowerCase();
+      let matchCount = 0;
+      for (const term of queryTerms) {
+        const regex = new RegExp(term, "gi");
+        const matches = contentLower.match(regex);
+        if (matches)
+          matchCount += matches.length;
+      }
+      if (matchCount === 0)
+        continue;
+      const score = Math.min(1, matchCount / (queryTerms.length * 3));
+      if (score < minScore)
+        continue;
+      let bestSnippetStart = 0;
+      let bestSnippetEnd = Math.min(lines.length, 5);
+      for (let i = 0;i < lines.length; i++) {
+        const lineLower = lines[i].toLowerCase();
+        for (const term of queryTerms) {
+          if (lineLower.includes(term)) {
+            bestSnippetStart = Math.max(0, i - 2);
+            bestSnippetEnd = Math.min(lines.length, i + 3);
+            break;
+          }
+        }
+      }
+      const snippet = lines.slice(bestSnippetStart, bestSnippetEnd).join(`
+`);
+      results.push({
+        path: entry.path,
+        startLine: bestSnippetStart + 1,
+        endLine: bestSnippetEnd,
+        score,
+        snippet,
+        entryId: entry.id
+      });
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, maxResults);
+  }
+  async delete(id) {
+    const filePath = this.getFilePath(id);
+    try {
+      await fs.unlink(filePath);
+      import_core.logger.info(`[ScratchpadService] Deleted entry: ${id}`);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async getSummary() {
+    const entries = await this.list();
+    if (entries.length === 0) {
+      return "No scratchpad entries found.";
+    }
+    const summaryParts = [`**Scratchpad Summary** (${entries.length} entries)`, ""];
+    for (const entry of entries.slice(0, 10)) {
+      const preview = entry.content.replace(/^---[\s\S]*?---\n*/m, "").substring(0, 100).replace(/\n/g, " ").trim();
+      summaryParts.push(`- **${entry.title}** (${entry.id})`);
+      summaryParts.push(`  ${preview}${preview.length >= 100 ? "..." : ""}`);
+      summaryParts.push(`  _Modified: ${entry.modifiedAt.toLocaleDateString()}_`);
+    }
+    if (entries.length > 10) {
+      summaryParts.push(`
+_...and ${entries.length - 10} more entries_`);
+    }
+    return summaryParts.join(`
+`);
+  }
+  getBasePath() {
+    return this.config.basePath;
+  }
+}
+function createScratchpadService(runtime, config) {
+  return new ScratchpadService(runtime, config);
+}
+
+// actions/append.ts
+function isValidAppendInput(obj) {
+  return typeof obj.id === "string" && obj.id.length > 0 && typeof obj.content === "string" && obj.content.length > 0;
+}
+var EXTRACT_TEMPLATE = `Extract the scratchpad entry ID and content to append from the user's message.
+
+User message: {{text}}
+
+Available scratchpad entries:
+{{entries}}
+
+Respond with XML containing:
+- id: The ID of the scratchpad entry to append to (required)
+- content: The new content to append (required)
+
+<response>
+<id>entry-id</id>
+<content>Content to append</content>
+</response>`;
+async function extractAppendInfo(runtime, message, availableEntries) {
+  const prompt = EXTRACT_TEMPLATE.replace("{{text}}", message.content.text ?? "").replace("{{entries}}", availableEntries);
+  const result = await runtime.useModel(import_core2.ModelType.TEXT_SMALL, {
+    prompt,
+    stopSequences: []
+  });
+  import_core2.logger.debug("[ScratchpadAppend] Extract result:", result);
+  const parsed = import_core2.parseKeyValueXml(String(result));
+  if (!parsed || !isValidAppendInput(parsed)) {
+    import_core2.logger.error("[ScratchpadAppend] Failed to extract valid append info");
+    return null;
+  }
+  return {
+    id: String(parsed.id),
+    content: String(parsed.content)
+  };
+}
+var spec = requireActionSpec("SCRATCHPAD_APPEND");
+var scratchpadAppendAction = {
+  name: spec.name,
+  similes: spec.similes ? [...spec.similes] : [],
+  description: spec.description,
+  validate: async (_runtime, _message) => {
+    return true;
+  },
+  handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+    const service = createScratchpadService(runtime);
+    const entries = await service.list();
+    const entriesContext = entries.map((e) => `- ${e.id}: "${e.title}"`).join(`
+`);
+    if (entries.length === 0) {
+      if (callback) {
+        await callback({
+          text: "There are no scratchpad entries to append to. Create one first with SCRATCHPAD_WRITE.",
+          actions: ["SCRATCHPAD_APPEND_EMPTY"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "No entries available" };
+    }
+    const appendInfo = await extractAppendInfo(runtime, message, entriesContext);
+    if (!appendInfo) {
+      if (callback) {
+        await callback({
+          text: `I couldn't determine which note to update or what to add. Available entries:
+${entriesContext}`,
+          actions: ["SCRATCHPAD_APPEND_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to extract append info" };
+    }
+    try {
+      const exists = await service.exists(appendInfo.id);
+      if (!exists) {
+        if (callback) {
+          await callback({
+            text: `Scratchpad entry "${appendInfo.id}" not found. Available entries:
+${entriesContext}`,
+            actions: ["SCRATCHPAD_APPEND_NOT_FOUND"],
+            source: message.content.source
+          });
+        }
+        return { success: false, text: "Entry not found" };
+      }
+      const existingEntry = await service.read(appendInfo.id);
+      const entry = await service.write(existingEntry.title, appendInfo.content, {
+        append: true,
+        tags: existingEntry.tags
+      });
+      const successMessage = `Successfully appended content to "${entry.title}" (${entry.id}).`;
+      if (callback) {
+        await callback({
+          text: successMessage,
+          actions: ["SCRATCHPAD_APPEND_SUCCESS"],
+          source: message.content.source
+        });
+      }
+      return { success: true, text: successMessage, entry };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core2.logger.error("[ScratchpadAppend] Error:", errorMsg);
+      if (callback) {
+        await callback({
+          text: `Failed to append to the note: ${errorMsg}`,
+          actions: ["SCRATCHPAD_APPEND_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to append to scratchpad entry" };
+    }
+  },
+  examples: []
+};
+
+// actions/delete.ts
+var import_core3 = require("@elizaos/core");
+function isValidDeleteInput(obj) {
+  return typeof obj.id === "string" && obj.id.length > 0;
+}
+var EXTRACT_TEMPLATE2 = `Extract the scratchpad entry ID to delete from the user's message.
+
+User message: {{text}}
+
+Available scratchpad entries:
+{{entries}}
+
+Respond with XML containing:
+- id: The ID of the scratchpad entry to delete (required)
+
+<response>
+<id>entry-id</id>
+</response>`;
+async function extractDeleteInfo(runtime, message, availableEntries) {
+  const prompt = EXTRACT_TEMPLATE2.replace("{{text}}", message.content.text ?? "").replace("{{entries}}", availableEntries);
+  const result = await runtime.useModel(import_core3.ModelType.TEXT_SMALL, {
+    prompt,
+    stopSequences: []
+  });
+  import_core3.logger.debug("[ScratchpadDelete] Extract result:", result);
+  const parsed = import_core3.parseKeyValueXml(String(result));
+  if (!parsed || !isValidDeleteInput(parsed)) {
+    import_core3.logger.error("[ScratchpadDelete] Failed to extract valid delete info");
+    return null;
+  }
+  return {
+    id: String(parsed.id)
+  };
+}
+var spec2 = requireActionSpec("SCRATCHPAD_DELETE");
+var scratchpadDeleteAction = {
+  name: spec2.name,
+  similes: spec2.similes ? [...spec2.similes] : [],
+  description: spec2.description,
+  validate: async (_runtime, _message) => {
+    return true;
+  },
+  handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+    const service = createScratchpadService(runtime);
+    const entries = await service.list();
+    const entriesContext = entries.map((e) => `- ${e.id}: "${e.title}"`).join(`
+`);
+    if (entries.length === 0) {
+      if (callback) {
+        await callback({
+          text: "There are no scratchpad entries to delete.",
+          actions: ["SCRATCHPAD_DELETE_EMPTY"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "No entries available" };
+    }
+    const deleteInfo = await extractDeleteInfo(runtime, message, entriesContext);
+    if (!deleteInfo) {
+      if (callback) {
+        await callback({
+          text: `I couldn't determine which note to delete. Available entries:
+${entriesContext}`,
+          actions: ["SCRATCHPAD_DELETE_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to extract delete info" };
+    }
+    try {
+      const deleted = await service.delete(deleteInfo.id);
+      if (!deleted) {
+        if (callback) {
+          await callback({
+            text: `Scratchpad entry "${deleteInfo.id}" not found.`,
+            actions: ["SCRATCHPAD_DELETE_NOT_FOUND"],
+            source: message.content.source
+          });
+        }
+        return { success: false, text: "Entry not found" };
+      }
+      const successMessage = `Successfully deleted scratchpad entry "${deleteInfo.id}".`;
+      if (callback) {
+        await callback({
+          text: successMessage,
+          actions: ["SCRATCHPAD_DELETE_SUCCESS"],
+          source: message.content.source
+        });
+      }
+      return { success: true, text: successMessage };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core3.logger.error("[ScratchpadDelete] Error:", errorMsg);
+      if (callback) {
+        await callback({
+          text: `Failed to delete the note: ${errorMsg}`,
+          actions: ["SCRATCHPAD_DELETE_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to delete scratchpad entry" };
+    }
+  },
+  examples: []
+};
+
+// actions/list.ts
+var import_core4 = require("@elizaos/core");
+var spec3 = requireActionSpec("SCRATCHPAD_LIST");
+var scratchpadListAction = {
+  name: spec3.name,
+  similes: spec3.similes ? [...spec3.similes] : [],
+  description: spec3.description,
+  validate: async (_runtime, _message) => {
+    return true;
+  },
+  handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+    try {
+      const service = createScratchpadService(runtime);
+      const entries = await service.list();
+      if (entries.length === 0) {
+        if (callback) {
+          await callback({
+            text: "You don't have any scratchpad entries yet. Use SCRATCHPAD_WRITE to create one.",
+            actions: ["SCRATCHPAD_LIST_EMPTY"],
+            source: message.content.source
+          });
+        }
+        return { success: true, text: "No entries", entries: [] };
+      }
+      const listText = entries.map((e, i) => {
+        const tagsStr = e.tags?.length ? ` [${e.tags.join(", ")}]` : "";
+        return `${i + 1}. **${e.title}** (${e.id})${tagsStr}
+   _Modified: ${e.modifiedAt.toLocaleDateString()}_`;
+      }).join(`
+`);
+      const successMessage = `**Your Scratchpad Entries** (${entries.length} total):
+
+${listText}`;
+      if (callback) {
+        await callback({
+          text: successMessage,
+          actions: ["SCRATCHPAD_LIST_SUCCESS"],
+          source: message.content.source
+        });
+      }
+      return { success: true, text: successMessage, entries };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core4.logger.error("[ScratchpadList] Error:", errorMsg);
+      if (callback) {
+        await callback({
+          text: `Failed to list scratchpad entries: ${errorMsg}`,
+          actions: ["SCRATCHPAD_LIST_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to list scratchpad entries" };
+    }
+  },
+  examples: []
+};
+
+// actions/read.ts
+var import_core5 = require("@elizaos/core");
+function isValidReadInput(obj) {
+  return typeof obj.id === "string" && obj.id.length > 0;
+}
+var EXTRACT_TEMPLATE3 = `Extract the scratchpad entry ID and optional line range from the user's message.
+
+User message: {{text}}
+
+Available scratchpad entries:
+{{entries}}
+
+Respond with XML containing:
+- id: The ID of the scratchpad entry to read (required)
+- from: Starting line number (optional)
+- lines: Number of lines to read (optional)
+
+<response>
+<id>entry-id</id>
+<from>1</from>
+<lines>10</lines>
+</response>`;
+async function extractReadInfo(runtime, message, availableEntries) {
+  const prompt = EXTRACT_TEMPLATE3.replace("{{text}}", message.content.text ?? "").replace("{{entries}}", availableEntries);
+  const result = await runtime.useModel(import_core5.ModelType.TEXT_SMALL, {
+    prompt,
+    stopSequences: []
+  });
+  import_core5.logger.debug("[ScratchpadRead] Extract result:", result);
+  const parsed = import_core5.parseKeyValueXml(String(result));
+  if (!parsed || !isValidReadInput(parsed)) {
+    import_core5.logger.error("[ScratchpadRead] Failed to extract valid read info");
+    return null;
+  }
+  return {
+    id: String(parsed.id),
+    from: parsed.from ? Number(parsed.from) : undefined,
+    lines: parsed.lines ? Number(parsed.lines) : undefined
+  };
+}
+var spec4 = requireActionSpec("SCRATCHPAD_READ");
+var scratchpadReadAction = {
+  name: spec4.name,
+  similes: spec4.similes ? [...spec4.similes] : [],
+  description: spec4.description,
+  validate: async (_runtime, _message) => {
+    return true;
+  },
+  handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+    const service = createScratchpadService(runtime);
+    const entries = await service.list();
+    const entriesContext = entries.map((e) => `- ${e.id}: "${e.title}"`).join(`
+`);
+    if (entries.length === 0) {
+      if (callback) {
+        await callback({
+          text: "There are no scratchpad entries to read. You can create one first.",
+          actions: ["SCRATCHPAD_READ_EMPTY"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "No entries available" };
+    }
+    const readInfo = await extractReadInfo(runtime, message, entriesContext);
+    if (!readInfo) {
+      if (callback) {
+        await callback({
+          text: `I couldn't determine which note to read. Available entries:
+${entriesContext}`,
+          actions: ["SCRATCHPAD_READ_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to extract read info" };
+    }
+    try {
+      const entry = await service.read(readInfo.id, {
+        from: readInfo.from,
+        lines: readInfo.lines
+      });
+      const lineInfo = readInfo.from !== undefined ? ` (lines ${readInfo.from}-${(readInfo.from ?? 1) + (readInfo.lines ?? 10)})` : "";
+      const successMessage = `**${entry.title}**${lineInfo}
+
+${entry.content}`;
+      if (callback) {
+        await callback({
+          text: successMessage,
+          actions: ["SCRATCHPAD_READ_SUCCESS"],
+          source: message.content.source
+        });
+      }
+      return { success: true, text: successMessage, entry };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core5.logger.error("[ScratchpadRead] Error:", errorMsg);
+      if (callback) {
+        await callback({
+          text: `Failed to read the note: ${errorMsg}`,
+          actions: ["SCRATCHPAD_READ_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to read scratchpad entry" };
+    }
+  },
+  examples: []
+};
+
+// actions/search.ts
+var import_core6 = require("@elizaos/core");
+function isValidSearchInput(obj) {
+  return typeof obj.query === "string" && obj.query.length > 0;
+}
+var EXTRACT_TEMPLATE4 = `Extract the search query from the user's message.
+
+User message: {{text}}
+
+Respond with XML containing:
+- query: The search terms to find in scratchpad entries (required)
+- maxResults: Maximum number of results to return (optional, default 5)
+
+<response>
+<query>search terms</query>
+<maxResults>5</maxResults>
+</response>`;
+async function extractSearchInfo(runtime, message) {
+  const prompt = EXTRACT_TEMPLATE4.replace("{{text}}", message.content.text ?? "");
+  const result = await runtime.useModel(import_core6.ModelType.TEXT_SMALL, {
+    prompt,
+    stopSequences: []
+  });
+  import_core6.logger.debug("[ScratchpadSearch] Extract result:", result);
+  const parsed = import_core6.parseKeyValueXml(String(result));
+  if (!parsed || !isValidSearchInput(parsed)) {
+    import_core6.logger.error("[ScratchpadSearch] Failed to extract valid search info");
+    return null;
+  }
+  return {
+    query: String(parsed.query),
+    maxResults: parsed.maxResults ? Number(parsed.maxResults) : 5
+  };
+}
+var spec5 = requireActionSpec("SCRATCHPAD_SEARCH");
+var scratchpadSearchAction = {
+  name: spec5.name,
+  similes: spec5.similes ? [...spec5.similes] : [],
+  description: spec5.description,
+  validate: async (_runtime, _message) => {
+    return true;
+  },
+  handler: async (runtime, message, _stateFromTrigger, _options, callback, _responses) => {
+    const searchInfo = await extractSearchInfo(runtime, message);
+    if (!searchInfo) {
+      if (callback) {
+        await callback({
+          text: "I couldn't understand what you're searching for. Please provide search terms.",
+          actions: ["SCRATCHPAD_SEARCH_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to extract search info" };
+    }
+    try {
+      const service = createScratchpadService(runtime);
+      const results = await service.search(searchInfo.query, {
+        maxResults: searchInfo.maxResults
+      });
+      if (results.length === 0) {
+        if (callback) {
+          await callback({
+            text: `No scratchpad entries found matching "${searchInfo.query}".`,
+            actions: ["SCRATCHPAD_SEARCH_EMPTY"],
+            source: message.content.source
+          });
+        }
+        return { success: true, text: "No results found", results: [] };
+      }
+      const resultText = results.map((r, i) => {
+        const scorePercent = Math.round(r.score * 100);
+        return `**${i + 1}. ${r.entryId}** (${scorePercent}% match, lines ${r.startLine}-${r.endLine})
+\`\`\`
+${r.snippet.substring(0, 200)}${r.snippet.length > 200 ? "..." : ""}
+\`\`\``;
+      }).join(`
+
+`);
+      const successMessage = `Found ${results.length} matching scratchpad entries for "${searchInfo.query}":
+
+${resultText}
+
+Use SCRATCHPAD_READ with an entry ID to view the full content.`;
+      if (callback) {
+        await callback({
+          text: successMessage,
+          actions: ["SCRATCHPAD_SEARCH_SUCCESS"],
+          source: message.content.source
+        });
+      }
+      return { success: true, text: successMessage, results };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core6.logger.error("[ScratchpadSearch] Error:", errorMsg);
+      if (callback) {
+        await callback({
+          text: `Failed to search scratchpad: ${errorMsg}`,
+          actions: ["SCRATCHPAD_SEARCH_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to search scratchpad" };
+    }
+  },
+  examples: []
+};
+
+// actions/write.ts
+var import_core7 = require("@elizaos/core");
+function isValidWriteInput(obj) {
+  return typeof obj.title === "string" && obj.title.length > 0 && typeof obj.content === "string" && obj.content.length > 0;
+}
+var EXTRACT_TEMPLATE5 = `Extract the following information from the user's message to save to the scratchpad:
+
+User message: {{text}}
+
+Recent conversation:
+{{messageHistory}}
+
+Respond with XML containing:
+- title: A short, descriptive title for the note (required)
+- content: The main content to save (required)
+- tags: Comma-separated tags for categorization (optional)
+
+<response>
+<title>The note title</title>
+<content>The content to save</content>
+<tags>tag1, tag2</tags>
+</response>`;
+async function extractWriteInfo(runtime, message, _state) {
+  const prompt = EXTRACT_TEMPLATE5.replace("{{text}}", message.content.text ?? "").replace("{{messageHistory}}", "");
+  const result = await runtime.useModel(import_core7.ModelType.TEXT_SMALL, {
+    prompt,
+    stopSequences: []
+  });
+  import_core7.logger.debug("[ScratchpadWrite] Extract result:", result);
+  const parsed = import_core7.parseKeyValueXml(String(result));
+  if (!parsed || !isValidWriteInput(parsed)) {
+    import_core7.logger.error("[ScratchpadWrite] Failed to extract valid write info");
+    return null;
+  }
+  const tags = parsed.tags ? String(parsed.tags).split(",").map((t) => t.trim()).filter(Boolean) : undefined;
+  return {
+    title: String(parsed.title),
+    content: String(parsed.content),
+    tags
+  };
+}
+var spec6 = requireActionSpec("SCRATCHPAD_WRITE");
+var scratchpadWriteAction = {
+  name: spec6.name,
+  similes: spec6.similes ? [...spec6.similes] : [],
+  description: spec6.description,
+  validate: async (_runtime, _message) => {
+    return true;
+  },
+  handler: async (runtime, message, stateFromTrigger, _options, callback, _responses) => {
+    const state = stateFromTrigger ?? await runtime.composeState(message, []);
+    const writeInfo = await extractWriteInfo(runtime, message, state);
+    if (!writeInfo) {
+      if (callback) {
+        await callback({
+          text: "I couldn't understand what you want me to save. Please provide a clear title and content for the note.",
+          actions: ["SCRATCHPAD_WRITE_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to extract write info" };
+    }
+    try {
+      const service = createScratchpadService(runtime);
+      const entry = await service.write(writeInfo.title, writeInfo.content, {
+        tags: writeInfo.tags
+      });
+      const successMessage = `I've saved a note titled "${entry.title}" (ID: ${entry.id}).${entry.tags?.length ? ` Tags: ${entry.tags.join(", ")}` : ""} You can retrieve it later using the ID or by searching for it.`;
+      if (callback) {
+        await callback({
+          text: successMessage,
+          actions: ["SCRATCHPAD_WRITE_SUCCESS"],
+          source: message.content.source
+        });
+      }
+      return { success: true, text: successMessage, entryId: entry.id };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core7.logger.error("[ScratchpadWrite] Error:", errorMsg);
+      if (callback) {
+        await callback({
+          text: `Failed to save the note: ${errorMsg}`,
+          actions: ["SCRATCHPAD_WRITE_FAILED"],
+          source: message.content.source
+        });
+      }
+      return { success: false, text: "Failed to write to scratchpad" };
+    }
+  },
+  examples: []
+};
+
+// providers/scratchpad.ts
+var import_core8 = require("@elizaos/core");
+var scratchpadProvider = {
+  name: "scratchpad",
+  description: "Provides information about the user's scratchpad entries - file-based notes and memories that persist across sessions.",
+  get: async (runtime, _message, _state) => {
+    try {
+      const service = createScratchpadService(runtime);
+      const entries = await service.list();
+      if (entries.length === 0) {
+        return {
+          text: "No scratchpad entries available.",
+          data: { entries: [], count: 0 },
+          values: { scratchpadCount: 0 }
+        };
+      }
+      const summaryLines = [`**Scratchpad** (${entries.length} entries available):`, ""];
+      const recentEntries = entries.slice(0, 5);
+      for (const entry of recentEntries) {
+        const contentWithoutFrontmatter = entry.content.replace(/^---[\s\S]*?---\n*/m, "").trim();
+        const preview = contentWithoutFrontmatter.substring(0, 80).replace(/\n/g, " ");
+        const tagsStr = entry.tags?.length ? ` [${entry.tags.join(", ")}]` : "";
+        summaryLines.push(`- **${entry.title}** (${entry.id})${tagsStr}`);
+        summaryLines.push(`  ${preview}${contentWithoutFrontmatter.length > 80 ? "..." : ""}`);
+      }
+      if (entries.length > 5) {
+        summaryLines.push(`
+_...and ${entries.length - 5} more entries_`);
+      }
+      summaryLines.push(`
+_Use SCRATCHPAD_SEARCH to find specific entries or SCRATCHPAD_READ to view full content._`);
+      const entryData = entries.map((e) => ({
+        id: e.id,
+        title: e.title,
+        modifiedAt: e.modifiedAt.toISOString(),
+        tags: e.tags ?? []
+      }));
+      return {
+        text: summaryLines.join(`
+`),
+        data: {
+          entries: entryData,
+          count: entries.length,
+          basePath: service.getBasePath()
+        },
+        values: {
+          scratchpadCount: entries.length,
+          scratchpadEntryIds: entries.map((e) => e.id).join(", ")
+        }
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      import_core8.logger.error("[ScratchpadProvider] Error:", errorMsg);
+      return {
+        text: "Scratchpad service unavailable.",
+        data: { error: errorMsg },
+        values: { scratchpadCount: 0 }
+      };
+    }
+  }
+};
+
+// index.ts
+var scratchpadPlugin = {
+  name: "scratchpad",
+  description: "File-based memory storage for persistent notes and memories that can be written, read, searched, and managed across sessions.",
+  providers: [scratchpadProvider],
+  actions: [
+    scratchpadWriteAction,
+    scratchpadReadAction,
+    scratchpadSearchAction,
+    scratchpadListAction,
+    scratchpadDeleteAction,
+    scratchpadAppendAction
+  ],
+  async init(_config, _runtime) {
+    try {
+      import_core9.logger.info("[ScratchpadPlugin] Initializing...");
+      import_core9.logger.info("[ScratchpadPlugin] Initialized successfully");
+    } catch (error) {
+      import_core9.logger.error("[ScratchpadPlugin] Error initializing:", error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }
+};
+var typescript_default = scratchpadPlugin;
+
+//# debugId=3C48A2EDC93D045364756E2164756E21