@poncho-ai/harness 0.35.0 → 0.36.0

package/src/memory.ts

@@ -1,14 +1,5 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
 import { defineTool, type ToolContext, type ToolDefinition } from "@poncho-ai/sdk";
 import type { StateProviderName } from "./state.js";
-import {
-  ensureAgentIdentity,
-  getAgentStoreDirectory,
-  slugifyStorageComponent,
-  STORAGE_SCHEMA_VERSION,
-} from "./agent-identity.js";
-import { createRawKVStore, type RawKVStore } from "./kv-store.js";
 
 export interface MainMemory {
   content: string;
@@ -31,10 +22,6 @@ export interface MemoryStore {
   updateMainMemory(input: { content: string }): Promise<MainMemory>;
 }
 
-type MainMemoryPayload = {
-  main: MainMemory;
-};
-
 type RecallItem = {
   conversationId: string;
   title: string;
@@ -42,18 +29,27 @@ type RecallItem = {
   content: string;
 };
 
+type ConversationListItem = {
+  conversationId: string;
+  title: string;
+  createdAt?: number;
+  updatedAt: number;
+  messageCount?: number;
+};
+
+type ConversationDetail = {
+  conversationId: string;
+  title: string;
+  createdAt?: number;
+  updatedAt: number;
+  messages: Array<{ role: string; content: string }>;
+};
+
+
 const DEFAULT_MAIN_MEMORY: MainMemory = {
   content: "",
   updatedAt: 0,
 };
-const LOCAL_MEMORY_FILE = "memory.json";
-
-const writeJsonAtomic = async (filePath: string, payload: unknown): Promise<void> => {
-  await mkdir(dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  await writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8");
-  await rename(tmpPath, filePath);
-};
 
 const scoreText = (text: string, query: string): number => {
   const normalized = query.trim().toLowerCase();
@@ -99,167 +95,12 @@ class InMemoryMemoryStore implements MemoryStore {
   }
 }
 
-class FileMainMemoryStore implements MemoryStore {
-  private readonly workingDir: string;
-  private filePath = "";
-  private readonly customRelPath?: string;
-  private readonly ttlMs?: number;
-  private loaded = false;
-  private writing = Promise.resolve();
-  private mainMemory: MainMemory = { ...DEFAULT_MAIN_MEMORY };
-
-  constructor(workingDir: string, ttlSeconds?: number, customRelPath?: string) {
-    this.workingDir = workingDir;
-    this.ttlMs = typeof ttlSeconds === "number" ? ttlSeconds * 1000 : undefined;
-    this.customRelPath = customRelPath;
-  }
-
-  private async ensureFilePath(): Promise<void> {
-    if (this.filePath) {
-      return;
-    }
-    const identity = await ensureAgentIdentity(this.workingDir);
-    this.filePath = resolve(
-      getAgentStoreDirectory(identity),
-      this.customRelPath ?? LOCAL_MEMORY_FILE,
-    );
-  }
-
-  private isExpired(updatedAt: number): boolean {
-    return typeof this.ttlMs === "number" && Date.now() - updatedAt > this.ttlMs;
-  }
-
-  private async ensureLoaded(): Promise<void> {
-    await this.ensureFilePath();
-    if (this.loaded) {
-      return;
-    }
-    this.loaded = true;
-    try {
-      const raw = await readFile(this.filePath, "utf8");
-      const parsed = JSON.parse(raw) as MainMemoryPayload;
-      const content = typeof parsed.main?.content === "string" ? parsed.main.content : "";
-      const updatedAt = typeof parsed.main?.updatedAt === "number" ? parsed.main.updatedAt : 0;
-      this.mainMemory = { content, updatedAt };
-    } catch {
-      // Missing or invalid file should not crash local mode.
-    }
-  }
-
-  private async persist(): Promise<void> {
-    const payload: MainMemoryPayload = { main: this.mainMemory };
-    this.writing = this.writing.then(async () => {
-      await writeJsonAtomic(this.filePath, payload);
-    });
-    await this.writing;
-  }
-
-  async getMainMemory(): Promise<MainMemory> {
-    await this.ensureLoaded();
-    if (this.mainMemory.updatedAt > 0 && this.isExpired(this.mainMemory.updatedAt)) {
-      this.mainMemory = { ...DEFAULT_MAIN_MEMORY };
-      await this.persist();
-    }
-    return this.mainMemory;
-  }
-
-  async updateMainMemory(input: { content: string }): Promise<MainMemory> {
-    await this.ensureLoaded();
-    this.mainMemory = {
-      content: input.content.trim(),
-      updatedAt: Date.now(),
-    };
-    await this.persist();
-    return this.mainMemory;
-  }
-}
-
-class KVBackedMemoryStore implements MemoryStore {
-  private readonly kv: RawKVStore;
-  private readonly storageKey: string;
-  private readonly ttl?: number;
-  private readonly memoryFallback: InMemoryMemoryStore;
-
-  constructor(kv: RawKVStore, storageKey: string, ttl?: number) {
-    this.kv = kv;
-    this.storageKey = storageKey;
-    this.ttl = ttl;
-    this.memoryFallback = new InMemoryMemoryStore(ttl);
-  }
-
-  private async readPayload(): Promise<MainMemoryPayload> {
-    try {
-      const raw = await this.kv.get(this.storageKey);
-      if (!raw) return { main: { ...DEFAULT_MAIN_MEMORY } };
-      const parsed = JSON.parse(raw) as MainMemoryPayload;
-      const content = typeof parsed.main?.content === "string" ? parsed.main.content : "";
-      const updatedAt = typeof parsed.main?.updatedAt === "number" ? parsed.main.updatedAt : 0;
-      return { main: { content, updatedAt } };
-    } catch {
-      const main = await this.memoryFallback.getMainMemory();
-      return { main };
-    }
-  }
-
-  private async writePayload(payload: MainMemoryPayload): Promise<void> {
-    try {
-      const serialized = JSON.stringify(payload);
-      if (typeof this.ttl === "number") {
-        await this.kv.setWithTtl(this.storageKey, serialized, Math.max(1, this.ttl));
-      } else {
-        await this.kv.set(this.storageKey, serialized);
-      }
-    } catch {
-      await this.memoryFallback.updateMainMemory({ content: payload.main.content });
-    }
-  }
-
-  async getMainMemory(): Promise<MainMemory> {
-    const payload = await this.readPayload();
-    return payload.main;
-  }
-
-  async updateMainMemory(input: { content: string }): Promise<MainMemory> {
-    const payload = await this.readPayload();
-    payload.main = { content: input.content.trim(), updatedAt: Date.now() };
-    await this.writePayload(payload);
-    return payload.main;
-  }
-}
-
 export const createMemoryStore = (
   agentId: string,
   config?: MemoryConfig,
   options?: { workingDir?: string; tenantId?: string },
 ): MemoryStore => {
-  const provider = config?.provider ?? "local";
   const ttl = config?.ttl;
-  const workingDir = options?.workingDir ?? process.cwd();
-  const tenantId = options?.tenantId;
-
-  if (provider === "local") {
-    if (tenantId) {
-      // Tenant-scoped memory: store under tenants/{tenantId}/memory.json
-      return new FileMainMemoryStore(
-        workingDir,
-        ttl,
-        `tenants/${slugifyStorageComponent(tenantId)}/${LOCAL_MEMORY_FILE}`,
-      );
-    }
-    return new FileMainMemoryStore(workingDir, ttl);
-  }
-  if (provider === "memory") {
-    return new InMemoryMemoryStore(ttl);
-  }
-
-  const kv = createRawKVStore(config);
-  if (kv) {
-    const base = `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}`;
-    const storageKey = tenantId
-      ? `${base}:t:${slugifyStorageComponent(tenantId)}:memory:main`
-      : `${base}:memory:main`;
-    return new KVBackedMemoryStore(kv, storageKey, ttl);
-  }
   return new InMemoryMemoryStore(ttl);
 };
 
@@ -397,56 +238,146 @@ export const createMemoryTools = (
     defineTool({
       name: "conversation_recall",
       description:
-        "Recall relevant snippets from previous conversations when prior context is likely important (for example: 'as we discussed', 'last time', or ambiguous references).",
+        "Recall past conversations. Three modes:\n" +
+        "- Search: provide 'query' to keyword-search past conversations for relevant snippets.\n" +
+        "- List: provide 'after' and/or 'before' dates to browse conversations by date range.\n" +
+        "- Fetch: provide 'conversationId' to load the full message history of a specific conversation.\n" +
+        "Modes can be combined (e.g. query + date range to search within a time window).",
       inputSchema: {
         type: "object",
         properties: {
           query: {
             type: "string",
-            description: "Search query for past conversation recall",
+            description: "Keyword search query for past conversations",
           },
-          limit: {
-            type: "number",
-            description: "Maximum snippets to return",
+          after: {
+            type: "string",
+            description:
+              "ISO 8601 date string. Only return conversations updated after this date (e.g. '2025-03-01').",
           },
-          excludeConversationId: {
+          before: {
             type: "string",
-            description: "Optional conversation id to exclude from recall",
+            description:
+              "ISO 8601 date string. Only return conversations updated before this date.",
+          },
+          conversationId: {
+            type: "string",
+            description: "Fetch the full message history of a specific conversation by ID",
+          },
+          lastN: {
+            type: "number",
+            description: "When fetching a conversation, only return the last N messages (max 50)",
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results to return (default 20 for list, 3 for search, max 50)",
           },
         },
-        required: ["query"],
         additionalProperties: false,
       },
       handler: async (input, context) => {
         const query = typeof input.query === "string" ? input.query.trim() : "";
-        if (!query) {
-          throw new Error("query is required");
+        const after = typeof input.after === "string" ? input.after : "";
+        const before = typeof input.before === "string" ? input.before : "";
+        const fetchId = typeof input.conversationId === "string" ? input.conversationId.trim() : "";
+        const hasDateFilter = after !== "" || before !== "";
+
+        // Determine mode
+        const mode = fetchId ? "fetch" : (query && !hasDateFilter) ? "search" : "list";
+
+        // --- Fetch mode: load full conversation by ID ---
+        if (mode === "fetch") {
+          const rawFetchFn = context.parameters.__conversationFetchFn;
+          if (typeof rawFetchFn !== "function") {
+            throw new Error("Conversation fetching is not available in this environment.");
+          }
+          const conversation = (await (rawFetchFn as (id: string) => Promise<unknown>)(fetchId)) as
+            | ConversationDetail
+            | undefined;
+          if (!conversation) {
+            throw new Error(`Conversation '${fetchId}' not found.`);
+          }
+          const lastN = typeof input.lastN === "number" ? Math.max(1, Math.min(50, input.lastN)) : undefined;
+          const messages = lastN
+            ? conversation.messages.slice(-lastN)
+            : conversation.messages.slice(-50);
+          return {
+            mode: "fetch",
+            conversationId: conversation.conversationId,
+            title: conversation.title,
+            createdAt: conversation.createdAt
+              ? new Date(conversation.createdAt).toISOString()
+              : undefined,
+            updatedAt: new Date(conversation.updatedAt).toISOString(),
+            messageCount: conversation.messages.length,
+            messages: messages.map((m) => ({
+              role: m.role,
+              content: m.content.slice(0, 4000),
+            })),
+          };
         }
+
+        // --- List mode: browse by date, optionally with keyword filtering ---
+        if (mode === "list") {
+          const rawListFn = context.parameters.__conversationListFn;
+          if (typeof rawListFn !== "function") {
+            throw new Error("Conversation listing is not available in this environment.");
+          }
+          const allConversations = (await (rawListFn as () => Promise<unknown>)()) as ConversationListItem[];
+          const limit = Math.max(1, Math.min(50, typeof input.limit === "number" ? input.limit : 20));
+          const afterMs = after ? new Date(after).getTime() : 0;
+          const beforeMs = before ? new Date(before).getTime() : Infinity;
+
+          let filtered = allConversations.filter((item) => {
+            const ts = item.updatedAt;
+            return ts >= afterMs && ts <= beforeMs;
+          });
+
+          // If query is also provided, score and rank by relevance
+          if (query) {
+            filtered = filtered
+              .map((item) => ({
+                ...item,
+                _score: scoreText(item.title, query),
+              }))
+              .filter((item) => item._score > 0)
+              .sort((a, b) => {
+                if (b._score === a._score) return b.updatedAt - a.updatedAt;
+                return b._score - a._score;
+              });
+          }
+
+          return {
+            mode: "list",
+            conversations: filtered.slice(0, limit).map((item) => ({
+              conversationId: item.conversationId,
+              title: item.title,
+              createdAt: item.createdAt
+                ? new Date(item.createdAt).toISOString()
+                : undefined,
+              updatedAt: new Date(item.updatedAt).toISOString(),
+              messageCount: item.messageCount,
+            })),
+          };
+        }
+
+        // --- Search mode: keyword search across conversation content ---
         const limit = Math.max(
           1,
-          Math.min(5, typeof input.limit === "number" ? input.limit : 3),
+          Math.min(10, typeof input.limit === "number" ? input.limit : 3),
         );
-        const excludeConversationId =
-          typeof input.excludeConversationId === "string"
-            ? input.excludeConversationId
-            : "";
         const rawCorpus = context.parameters.__conversationRecallCorpus;
         const resolvedCorpus =
           typeof rawCorpus === "function" ? await (rawCorpus as () => Promise<unknown>)() : rawCorpus;
         const corpus = asRecallCorpus(resolvedCorpus).slice(0, maxRecallConversations);
         const results = corpus
-          .filter((item) =>
-            excludeConversationId ? item.conversationId !== excludeConversationId : true,
-          )
           .map((item) => ({
             ...item,
             score: scoreText(`${item.title}\n${item.content}`, query),
           }))
           .filter((item) => item.score > 0)
           .sort((a, b) => {
-            if (b.score === a.score) {
-              return b.updatedAt - a.updatedAt;
-            }
+            if (b.score === a.score) return b.updatedAt - a.updatedAt;
             return b.score - a.score;
           })
           .slice(0, limit)
@@ -456,7 +387,7 @@ export const createMemoryTools = (
             updatedAt: item.updatedAt,
             snippet: buildRecallSnippet(item.content, query),
           }));
-        return { results };
+        return { mode: "search", results };
       },
     }),
   ];

package/src/reminder-store.ts

@@ -1,13 +1,4 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
 import type { StateConfig } from "./state.js";
-import {
-  ensureAgentIdentity,
-  getAgentStoreDirectory,
-  slugifyStorageComponent,
-  STORAGE_SCHEMA_VERSION,
-} from "./agent-identity.js";
-import { createRawKVStore, type RawKVStore } from "./kv-store.js";
 
 // ---------------------------------------------------------------------------
 // Data model
@@ -45,29 +36,8 @@ export interface ReminderStore {
 // Helpers
 // ---------------------------------------------------------------------------
 
-const REMINDERS_FILE = "reminders.json";
 const STALE_CANCELLED_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
 
-const writeJsonAtomic = async (filePath: string, payload: unknown): Promise<void> => {
-  await mkdir(dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  await writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8");
-  await rename(tmpPath, filePath);
-};
-
-const isValidReminder = (item: unknown): item is Reminder =>
-  typeof item === "object" &&
-  item !== null &&
-  typeof (item as Record<string, unknown>).id === "string" &&
-  typeof (item as Record<string, unknown>).task === "string" &&
-  typeof (item as Record<string, unknown>).scheduledAt === "number" &&
-  typeof (item as Record<string, unknown>).status === "string";
-
-const parseReminderList = (raw: unknown): Reminder[] => {
-  if (!Array.isArray(raw)) return [];
-  return raw.filter(isValidReminder);
-};
-
 /** Remove all fired reminders and cancelled reminders older than 7 days. */
 const pruneStale = (reminders: Reminder[]): Reminder[] => {
   const cutoff = Date.now() - STALE_CANCELLED_MS;
@@ -132,218 +102,14 @@ class InMemoryReminderStore implements ReminderStore {
   }
 }
 
-// ---------------------------------------------------------------------------
-// FileReminderStore — single JSON file for all reminders
-// ---------------------------------------------------------------------------
-
-class FileReminderStore implements ReminderStore {
-  private readonly workingDir: string;
-  private filePath = "";
-
-  constructor(workingDir: string) {
-    this.workingDir = workingDir;
-  }
-
-  private async ensureFilePath(): Promise<string> {
-    if (this.filePath) return this.filePath;
-    const identity = await ensureAgentIdentity(this.workingDir);
-    this.filePath = resolve(getAgentStoreDirectory(identity), REMINDERS_FILE);
-    return this.filePath;
-  }
-
-  private async readAll(): Promise<Reminder[]> {
-    try {
-      const fp = await this.ensureFilePath();
-      const raw = await readFile(fp, "utf8");
-      return parseReminderList(JSON.parse(raw));
-    } catch {
-      return [];
-    }
-  }
-
-  private async writeAll(reminders: Reminder[]): Promise<void> {
-    const fp = await this.ensureFilePath();
-    await writeJsonAtomic(fp, reminders);
-  }
-
-  async list(): Promise<Reminder[]> {
-    const all = await this.readAll();
-    const pruned = pruneStale(all);
-    if (pruned.length !== all.length) await this.writeAll(pruned);
-    return pruned;
-  }
-
-  async create(input: {
-    task: string;
-    scheduledAt: number;
-    timezone?: string;
-    conversationId: string;
-    ownerId?: string;
-    tenantId?: string | null;
-  }): Promise<Reminder> {
-    const reminder: Reminder = {
-      id: generateId(),
-      task: input.task,
-      scheduledAt: input.scheduledAt,
-      timezone: input.timezone,
-      status: "pending",
-      createdAt: Date.now(),
-      conversationId: input.conversationId,
-      ownerId: input.ownerId,
-      tenantId: input.tenantId,
-    };
-    let reminders = await this.readAll();
-    reminders = pruneStale(reminders);
-    reminders.push(reminder);
-    await this.writeAll(reminders);
-    return reminder;
-  }
-
-  async cancel(id: string): Promise<Reminder> {
-    const reminders = await this.readAll();
-    const reminder = reminders.find((r) => r.id === id);
-    if (!reminder) throw new Error(`Reminder "${id}" not found`);
-    if (reminder.status !== "pending") {
-      throw new Error(`Reminder "${id}" is already ${reminder.status}`);
-    }
-    reminder.status = "cancelled";
-    await this.writeAll(reminders);
-    return reminder;
-  }
-
-  async delete(id: string): Promise<void> {
-    const reminders = await this.readAll();
-    await this.writeAll(reminders.filter((r) => r.id !== id));
-  }
-}
-
-// ---------------------------------------------------------------------------
-// KVBackedReminderStore — wraps any RawKVStore (Upstash, Redis, DynamoDB)
-// ---------------------------------------------------------------------------
-
-class KVBackedReminderStore implements ReminderStore {
-  private readonly kv: RawKVStore;
-  private readonly key: string;
-  private readonly ttl?: number;
-  private readonly memoryFallback = new InMemoryReminderStore();
-
-  constructor(kv: RawKVStore, key: string, ttl?: number) {
-    this.kv = kv;
-    this.key = key;
-    this.ttl = ttl;
-  }
-
-  private async readAll(): Promise<Reminder[]> {
-    try {
-      const raw = await this.kv.get(this.key);
-      if (!raw) return [];
-      return parseReminderList(JSON.parse(raw));
-    } catch {
-      return this.memoryFallback.list();
-    }
-  }
-
-  private async writeAll(reminders: Reminder[]): Promise<void> {
-    try {
-      const serialized = JSON.stringify(reminders);
-      if (typeof this.ttl === "number") {
-        await this.kv.setWithTtl(this.key, serialized, Math.max(1, this.ttl));
-      } else {
-        await this.kv.set(this.key, serialized);
-      }
-    } catch {
-      // KV write failed; operations already applied in-memory via caller
-    }
-  }
-
-  async list(): Promise<Reminder[]> {
-    const all = await this.readAll();
-    const pruned = pruneStale(all);
-    if (pruned.length !== all.length) await this.writeAll(pruned);
-    return pruned;
-  }
-
-  async create(input: {
-    task: string;
-    scheduledAt: number;
-    timezone?: string;
-    conversationId: string;
-    ownerId?: string;
-  }): Promise<Reminder> {
-    let reminders: Reminder[];
-    try {
-      reminders = await this.readAll();
-    } catch {
-      return this.memoryFallback.create(input);
-    }
-    const reminder: Reminder = {
-      id: generateId(),
-      task: input.task,
-      scheduledAt: input.scheduledAt,
-      timezone: input.timezone,
-      status: "pending",
-      createdAt: Date.now(),
-      conversationId: input.conversationId,
-      ownerId: input.ownerId,
-    };
-    reminders = pruneStale(reminders);
-    reminders.push(reminder);
-    await this.writeAll(reminders);
-    return reminder;
-  }
-
-  async cancel(id: string): Promise<Reminder> {
-    let reminders: Reminder[];
-    try {
-      reminders = await this.readAll();
-    } catch {
-      return this.memoryFallback.cancel(id);
-    }
-    const reminder = reminders.find((r) => r.id === id);
-    if (!reminder) throw new Error(`Reminder "${id}" not found`);
-    if (reminder.status !== "pending") {
-      throw new Error(`Reminder "${id}" is already ${reminder.status}`);
-    }
-    reminder.status = "cancelled";
-    await this.writeAll(reminders);
-    return reminder;
-  }
-
-  async delete(id: string): Promise<void> {
-    let reminders: Reminder[];
-    try {
-      reminders = await this.readAll();
-    } catch {
-      return this.memoryFallback.delete(id);
-    }
-    await this.writeAll(reminders.filter((r) => r.id !== id));
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
 
 export const createReminderStore = (
-  agentId: string,
-  config?: StateConfig,
-  options?: { workingDir?: string },
+  _agentId: string,
+  _config?: StateConfig,
+  _options?: { workingDir?: string },
 ): ReminderStore => {
-  const provider = config?.provider ?? "local";
-  const ttl = config?.ttl;
-  const workingDir = options?.workingDir ?? process.cwd();
-
-  if (provider === "local") {
-    return new FileReminderStore(workingDir);
-  }
-  if (provider === "memory") {
-    return new InMemoryReminderStore();
-  }
-
-  const kv = createRawKVStore(config);
-  if (kv) {
-    const key = `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}:reminders`;
-    return new KVBackedReminderStore(kv, key, ttl);
-  }
   return new InMemoryReminderStore();
 };