@cursor/july 0.1.25 → 0.1.27

package/src/internal/builtin-tools/artifacts.test.ts

@@ -1,247 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { z } from "zod";
-import { defineArtifacts } from "../../artifacts.js";
-import { httpChannel } from "../../channels.js";
-import type { AgentProject, JsonSchemaObject } from "../../types.js";
-import { toolInputJsonSchema } from "../json-schema.js";
-import { SessionEngine, ToolInputError } from "../session-engine.js";
-import { tagArtifactTool } from "./artifacts.js";
-import { artifactBuiltinTool, TAG_ARTIFACT_TOOL_NAME } from "./index.js";
-
-const KINDS = defineArtifacts({
-  kinds: {
-    "reviewed-pr": {
-      description: "A pull request this agent reviewed.",
-      schema: z.object({ url: z.string(), verdict: z.string() }),
-    },
-    report: { description: "A generated report." },
-  },
-  agentTool: true,
-});
-
-describe("tagArtifactTool schema", () => {
-  it("builds a discriminated union over the declared kinds", () => {
-    const definition = tagArtifactTool(KINDS);
-    const jsonSchema = toolInputJsonSchema(definition.inputSchema);
-    const variants = (jsonSchema.anyOf ?? jsonSchema.oneOf) as Array<{
-      properties: Record<string, JsonSchemaObject>;
-      required?: string[];
-    }>;
-    expect(variants).toHaveLength(2);
-    expect(variants.map((v) => v.properties.kind?.const)).toEqual([
-      "reviewed-pr",
-      "report",
-    ]);
-    // The kind's zod schema shapes `data`; kinds without one pass through.
-    expect(variants[0]?.properties.data?.properties).toMatchObject({
-      url: { type: "string" },
-      verdict: { type: "string" },
-    });
-    expect(variants[1]?.properties.data?.additionalProperties).toBe(true);
-    for (const variant of variants) {
-      expect(variant.required).toEqual(
-        expect.arrayContaining(["kind", "data"])
-      );
-      expect(variant.required).not.toContain("title");
-      expect(variant.required).not.toContain("key");
-    }
-  });
-
-  it("keeps the author's data schema description", () => {
-    const definition = tagArtifactTool({
-      kinds: {
-        note: {
-          description: "A note.",
-          schema: z.object({ text: z.string() }).describe("Author-described."),
-        },
-      },
-      agentTool: true,
-    });
-    const jsonSchema = toolInputJsonSchema(definition.inputSchema);
-    const variants = (jsonSchema.anyOf ?? jsonSchema.oneOf) as Array<{
-      properties: Record<string, JsonSchemaObject>;
-    }>;
-    expect(variants[0]?.properties.data?.description).toBe("Author-described.");
-  });
-
-  it("rejects payloads that miss the kind schema", () => {
-    const definition = tagArtifactTool(KINDS);
-    const schema = definition.inputSchema as z.ZodTypeAny;
-    expect(
-      schema.safeParse({ kind: "reviewed-pr", data: { url: 1 } }).success
-    ).toBe(false);
-    expect(
-      schema.safeParse({
-        kind: "reviewed-pr",
-        data: { url: "https://x", verdict: "approved" },
-      }).success
-    ).toBe(true);
-    expect(schema.safeParse({ kind: "unknown", data: {} }).success).toBe(false);
-  });
-
-  it("rejects blank keys at the schema boundary and trims valid ones", () => {
-    const definition = tagArtifactTool(KINDS);
-    const schema = definition.inputSchema as z.ZodTypeAny;
-    expect(
-      schema.safeParse({ kind: "report", data: {}, key: "" }).success
-    ).toBe(false);
-    expect(
-      schema.safeParse({ kind: "report", data: {}, key: "   " }).success
-    ).toBe(false);
-    const parsed = schema.safeParse({
-      kind: "report",
-      data: {},
-      key: " pr-1 ",
-    });
-    expect(parsed.success).toBe(true);
-    expect((parsed as { data: { key: string } }).data.key).toBe("pr-1");
-  });
-
-  it("prompts with the kind descriptions and key upsert semantics", () => {
-    const definition = tagArtifactTool(KINDS);
-    expect(definition.description).toContain(
-      "- reviewed-pr: A pull request this agent reviewed."
-    );
-    expect(definition.description).toContain("- report: A generated report.");
-    expect(definition.description).toContain("upsert");
-    expect(definition.description).toContain("stable key");
-  });
-
-  it("requires at least one declared kind", () => {
-    expect(() => tagArtifactTool({ kinds: {} })).toThrow(/at least one/);
-  });
-});
-
-describe("tagArtifactTool execute", () => {
-  const cleanups: Array<() => Promise<void>> = [];
-
-  afterEach(async () => {
-    while (cleanups.length > 0) {
-      await cleanups.pop()?.();
-    }
-  });
-
-  async function makeEngine(
-    logger?: (line: string) => void
-  ): Promise<SessionEngine> {
-    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-tagtool-"));
-    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-    const tool = artifactBuiltinTool(KINDS);
-    if (tool === undefined) {
-      throw new Error("expected tag_artifact to be enabled");
-    }
-    const project: AgentProject = {
-      rootDir: stateRoot,
-      agentDir: join(stateRoot, "agent"),
-      name: "tag-artifact-test",
-      agent: {
-        name: "tag-artifact-test",
-        runtime: "local",
-        instructions: "Test agent.",
-        tools: [tool],
-        skills: [],
-        connections: [],
-        subagents: [],
-        seedFiles: [],
-      },
-      httpChannel: httpChannel(),
-      channels: [],
-      schedules: [],
-      hooks: [],
-      abs: [],
-      artifacts: KINDS,
-      diagnostics: [],
-    };
-    const engine = new SessionEngine({
-      project,
-      stateRoot,
-      logger,
-      runner: {
-        runTurn: () => {
-          throw new Error("no model turns in this test");
-        },
-      },
-    });
-    cleanups.push(() => engine.close());
-    return engine;
-  }
-
-  it("tags through ctx.artifacts with source model and confirms", async () => {
-    const engine = await makeEngine();
-    const outcome = await engine.callTool(TAG_ARTIFACT_TOOL_NAME, {
-      kind: "reviewed-pr",
-      data: { url: "https://github.com/org/repo/pull/1", verdict: "lgtm" },
-      title: "PR #1",
-      key: "pr-1",
-    });
-    expect(outcome.isError).toBe(false);
-    const rows = await engine.artifacts.list();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]).toMatchObject({
-      kind: "reviewed-pr",
-      key: "pr-1",
-      title: "PR #1",
-      data: { url: "https://github.com/org/repo/pull/1", verdict: "lgtm" },
-      source: "model",
-    });
-    expect(outcome.result).toEqual({
-      tagged: true,
-      id: rows[0]?.id,
-      kind: "reviewed-pr",
-      key: "pr-1",
-    });
-  });
-
-  it("logs the tag without the data payload", async () => {
-    const lines: string[] = [];
-    const engine = await makeEngine((line) => lines.push(line));
-    await engine.callTool(TAG_ARTIFACT_TOOL_NAME, {
-      kind: "report",
-      data: { secret: "do-not-log" },
-      key: "r-1",
-    });
-    const [record] = await engine.artifacts.list();
-    const logged = lines.find((line) =>
-      line.includes("[session] artifact tagged")
-    );
-    expect(logged).toBe(
-      `[session] artifact tagged kind=report id=${record?.id} source=model session=- key=r-1`
-    );
-    expect(lines.join("\n")).not.toContain("do-not-log");
-  });
-
-  it("rejects undeclared kinds and schema-invalid payloads at the boundary", async () => {
-    const engine = await makeEngine();
-    await expect(
-      engine.callTool(TAG_ARTIFACT_TOOL_NAME, { kind: "unknown", data: {} })
-    ).rejects.toThrow(ToolInputError);
-    await expect(
-      engine.callTool(TAG_ARTIFACT_TOOL_NAME, {
-        kind: "reviewed-pr",
-        data: { url: 1 },
-      })
-    ).rejects.toThrow(ToolInputError);
-  });
-});
-
-describe("artifactBuiltinTool", () => {
-  it("is enabled only by agentTool: true with kinds", () => {
-    expect(artifactBuiltinTool(undefined)).toBeUndefined();
-    expect(
-      artifactBuiltinTool({
-        kinds: { report: { description: "A report." } },
-      })
-    ).toBeUndefined();
-    expect(artifactBuiltinTool({ agentTool: true, kinds: {} })).toBeUndefined();
-
-    const tool = artifactBuiltinTool(KINDS);
-    expect(tool).toMatchObject({
-      name: TAG_ARTIFACT_TOOL_NAME,
-      execution: "server",
-      needsApproval: false,
-    });
-  });
-});

package/src/internal/builtin-tools/reminders.test.ts

@@ -1,201 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { httpChannel } from "../../channels.js";
-import type { AgentProject, ReminderInfo, SessionRecord } from "../../types.js";
-import { ReminderRunner } from "../reminder-runner.js";
-import { SessionEngine } from "../session-engine.js";
-import { builtinTools } from "./index.js";
-
-function testProject(rootDir: string): AgentProject {
-  return {
-    rootDir,
-    agentDir: join(rootDir, "agent"),
-    name: "builtin-reminders-test",
-    agent: {
-      name: "builtin-reminders-test",
-      runtime: "local",
-      instructions: "Test agent instructions.",
-      tools: builtinTools({ reminders: true }),
-      skills: [],
-      connections: [],
-      subagents: [],
-      seedFiles: [],
-    },
-    httpChannel: httpChannel(),
-    channels: [],
-    schedules: [],
-    hooks: [],
-    abs: [],
-    diagnostics: [],
-  };
-}
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-async function makeEngine(): Promise<SessionEngine> {
-  const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-builtin-rem-"));
-  cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
-  const engine = new SessionEngine({
-    project: testProject(stateRoot),
-    stateRoot,
-    runner: {
-      runTurn: () => {
-        throw new Error("no model turns in this test");
-      },
-    },
-  });
-  engine.setReminders(new ReminderRunner(engine));
-  return engine;
-}
-
-async function saveSession(
-  engine: SessionEngine,
-  sessionId: string,
-  continuationKey: string | null
-): Promise<void> {
-  const record: SessionRecord = {
-    sessionId,
-    channelId: "http",
-    mode: "chat",
-    continuationKey,
-    auth: null,
-    turnCount: 0,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-  };
-  await engine.sessions.save(record);
-}
-
-describe("built-in reminder tools", () => {
-  it("creates, lists, and cancels a reminder bound to the conversation", async () => {
-    const engine = await makeEngine();
-    await saveSession(engine, "ses_a", "conv:a");
-
-    const created = await engine.callTool(
-      "reminders_create",
-      {
-        prompt: "Re-check CI.",
-        every: "30m",
-        until: "Cancel once CI is green.",
-      },
-      { sessionId: "ses_a" }
-    );
-    expect(created.isError).toBe(false);
-    const reminder = created.result as { reminderId: string; until: string };
-    expect(reminder.reminderId).toMatch(/^rem_/);
-    expect(reminder.until).toBe("Cancel once CI is green.");
-
-    const listed = await engine.callTool(
-      "reminders_list",
-      {},
-      { sessionId: "ses_a" }
-    );
-    const list = listed.result as { reminders: Array<{ reminderId: string }> };
-    expect(list.reminders.map((r) => r.reminderId)).toEqual([
-      reminder.reminderId,
-    ]);
-
-    const cancelled = await engine.callTool(
-      "reminders_cancel",
-      { id: reminder.reminderId },
-      { sessionId: "ses_a" }
-    );
-    expect(cancelled.isError).toBe(false);
-    expect(cancelled.result).toEqual({
-      reminderId: reminder.reminderId,
-      status: "cancelled",
-    });
-
-    const after = await engine.callTool(
-      "reminders_list",
-      {},
-      { sessionId: "ses_a" }
-    );
-    expect((after.result as { reminders: unknown[] }).reminders).toEqual([]);
-  });
-
-  it("refuses to cancel another conversation's reminder", async () => {
-    const engine = await makeEngine();
-    await saveSession(engine, "ses_a", "conv:a");
-    await saveSession(engine, "ses_b", "conv:b");
-
-    const created = await engine.callTool(
-      "reminders_create",
-      { prompt: "wake", delay: "5m" },
-      { sessionId: "ses_a" }
-    );
-    const { reminderId } = created.result as { reminderId: string };
-
-    const foreign = await engine.callTool(
-      "reminders_cancel",
-      { id: reminderId },
-      { sessionId: "ses_b" }
-    );
-    expect(foreign.isError).toBe(true);
-    expect(foreign.errorMessage).toContain("in this conversation");
-
-    const mine = await engine.host.reminders?.list({ status: "armed" });
-    expect((mine as ReminderInfo[]).map((r) => r.id)).toEqual([reminderId]);
-  });
-
-  it("keeps reminders addressed across HTTP continuation rotation", async () => {
-    const engine = await makeEngine();
-    await saveSession(engine, "ses_a", "conv:a");
-
-    const created = await engine.callTool(
-      "reminders_create",
-      { prompt: "wake", delay: "5m" },
-      { sessionId: "ses_a" }
-    );
-    const { reminderId } = created.result as { reminderId: string };
-
-    // The built-in HTTP channel rotates the token after every follow-up.
-    await engine.setContinuationToken("ses_a", "conv:rotated");
-
-    const listed = await engine.callTool(
-      "reminders_list",
-      {},
-      { sessionId: "ses_a" }
-    );
-    const list = listed.result as { reminders: Array<{ reminderId: string }> };
-    expect(list.reminders.map((r) => r.reminderId)).toEqual([reminderId]);
-
-    // Fire path must still resolve the session (no session_gone disarm).
-    const dispatched = await engine.host.reminders?.dispatch(reminderId);
-    expect(dispatched).toMatchObject({ outcome: "fired", reason: "delivered" });
-  });
-
-  it("rejects sub-minute recurring reminders", async () => {
-    const engine = await makeEngine();
-    await saveSession(engine, "ses_a", "conv:a");
-
-    const outcome = await engine.callTool(
-      "reminders_create",
-      { prompt: "wake", every: "5s" },
-      { sessionId: "ses_a" }
-    );
-    expect(outcome.isError).toBe(true);
-    expect(outcome.errorMessage).toContain('every >= "1m"');
-  });
-
-  it("rejects creates from sessions without a continuation key", async () => {
-    const engine = await makeEngine();
-    await saveSession(engine, "ses_nokey", null);
-
-    const outcome = await engine.callTool(
-      "reminders_create",
-      { prompt: "wake", delay: "5m" },
-      { sessionId: "ses_nokey" }
-    );
-    expect(outcome.isError).toBe(true);
-    expect(outcome.errorMessage).toContain("followable");
-  });
-});