@chloejs/core 0.2.4 → 0.3.0

package/model/tools/own_files.ts

@@ -0,0 +1,46 @@
+// The tools over services/ownFilesService.ts: an agent reading and changing
+// its own folder, as far as its definition allows. `selfImprovement` with a
+// `selfImprovement` in the definition turns them on.
+import { z } from "zod";
+
+import type { Home, OwnFileRules } from "#chloe/load/load.ts";
+import { listOwn, readOwn, writeOwn } from "#chloe/services/ownFilesService.ts";
+import { tool, type Tools } from "../tool.ts";
+
+/** list_own_files, read_own_file and write_own_file, for the files `rules` lets it change. */
+export function ownFiles(rules: OwnFileRules): (agent: Home) => Tools {
+  const endings = rules.files.map((one) => `.${one.replace(/^\./, "")}`).join(", ");
+  const kept = rules.except?.length ? ` Never ${rules.except.join(", ")}.` : "";
+  return (agent) => ({
+    list_own_files: tool({
+      id: "list_own_files",
+      description:
+        "List the files in your own folder (your instructions, skills and jobs), and which of them you can " +
+        "change. Your memory is not in it: that is list_notes.",
+      inputSchema: z.object({}),
+      execute: () => listOwn(agent, rules),
+    }),
+    read_own_file: tool({
+      id: "read_own_file",
+      description:
+        "Read one file in your own folder, like instructions.md or jobs/morning-run.md. Read a file before you change it.",
+      inputSchema: z.object({ path: z.string().describe("A path inside your folder, from list_own_files.") }),
+      execute: ({ path }) => readOwn(agent, rules, path),
+    }),
+    write_own_file: tool({
+      id: "write_own_file",
+      description:
+        `Change one file in your own folder, ending in ${endings}.${kept} This replaces the whole file, so read it ` +
+        "first and include everything you want kept. A markdown file directly in skills/ is a skill, with name and " +
+        "description at the top. One directly in jobs/ is a job, with cron, description, timezone and model at the " +
+        "top, and a job you write runs at most once an hour. Code, your evals and your memory are not yours to " +
+        "write here. Every change is committed under your name with your message, so it can be seen and undone.",
+      inputSchema: z.object({
+        path: z.string().describe("A path inside your folder, like skills/deploys.md."),
+        content: z.string().min(1),
+        message: z.string().min(10).describe("What changed and why, as a commit message."),
+      }),
+      execute: ({ path, content, message }) => writeOwn(agent, rules, path, content, message),
+    }),
+  });
+}

package/model/tools/send_email.ts

@@ -5,25 +5,52 @@
 import { z } from "zod";
 
 import { type EmailSender, sendEmail } from "#chloe/services/emailService.ts";
-import { tool } from "#chloe/model/tool.ts";
+import { writeFiles } from "#chloe/services/filesService.ts";
+import { tool, type Tools } from "#chloe/model/tool.ts";
 
 interface Options extends EmailSender {
   /** Who it reaches and when to use it, in the agent's own words. Shown to the model. */
   when: string;
+  /**
+   * A folder in the agent's memory, like "outbox". Every email sent is copied
+   * there as `2026-09-23-0715-<subject>.md`, so the agent can see what it
+   * already said before saying it again. Unsaid, nothing is kept.
+   */
+  keep?: string;
 }
 
 /**
  * A tool that sends mail from the address the agent was given, to the address
  * it was given.
  */
-export function send_email({ when, ...sender }: Options) {
-  return tool({
-    id: "send_email",
-    description: `Send an email. ${when}`,
-    inputSchema: z.object({
-      subject: z.string().min(5).max(120),
-      body: z.string().min(20).describe("Plain text. Lead with what happened and what you did."),
+export function send_email({ when, keep, ...sender }: Options) {
+  return (agent: { name: string; memory: { folder: string; commit?: boolean | "each run" } }): Tools => ({
+    send_email: tool({
+      id: "send_email",
+      description: `Send an email. ${when}`,
+      inputSchema: z.object({
+        subject: z.string().min(5).max(120),
+        body: z
+          .string()
+          .min(20)
+          .describe(`${sender.markdown ? "Markdown" : "Plain text"}. Lead with what happened and what you did.`),
+      }),
+      execute: async ({ subject, body }) => {
+        const sent = await sendEmail(sender, subject, body);
+        if (!keep) return sent;
+        const at = new Date().toISOString();
+        const slug = subject.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+        const copy = `---\nto: ${sender.to.join(", ")}\nsubject: ${sent.subject}\nsent: ${at}\n---\n\n${body}\n`;
+        const { folder, commit } = agent.memory;
+        // With "each run", the end of the run commits the copy with everything else it wrote.
+        const kept = await writeFiles(folder, `${keep}/${at.slice(0, 16).replace("T", "-").replace(":", "")}-${slug}.md`, copy, {
+          commit: commit === true,
+          message: `Sent: ${sent.subject}`,
+          author: agent.name,
+          in: "memory",
+        });
+        return { ...sent, copy: kept.path };
+      },
     }),
-    execute: ({ subject, body }) => sendEmail(sender, subject, body),
   });
 }