@cursor/july 0.1.20 → 0.1.21

package/src/internal/install-cursor-skills.test.ts

@@ -0,0 +1,262 @@
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+import { describe, expect, it } from "vitest";
+import { packageRootDir } from "./distribution.js";
+import {
+  agentkitCursorSkillsDir,
+  cursorSkillsHome,
+  findMissingCursorSkills,
+  installCursorSkills,
+  listShippedPackageSkills,
+  offerInstallCursorSkills,
+  prepareSkillMarkdownForCursorInstall,
+  promptYesNo,
+  skillInstallPath,
+} from "./install-cursor-skills.js";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return mkdtemp(join(tmpdir(), prefix));
+}
+
+describe("listShippedPackageSkills", () => {
+  it("lists published package skills and skips operate", async () => {
+    const skills = await listShippedPackageSkills(packageRootDir());
+    const names = skills.map((skill) => skill.name);
+    const leaves = skills.map((skill) => skill.leafDir);
+
+    expect(names).toContain("agentkit-create-agent");
+    expect(names).toContain("agentkit-debug");
+    expect(leaves).toContain("create-agent");
+    expect(leaves).toContain("debug");
+    expect(names).not.toContain("agentkit-operate");
+    expect(leaves).not.toContain("operate");
+  });
+});
+
+describe("findMissingCursorSkills / installCursorSkills", () => {
+  it("installs under ~/.cursor/skills/agentkit/<leaf>", async () => {
+    const home = await makeTempDir("agentkit-skills-home-");
+    const missing = await findMissingCursorSkills({
+      packageRoot: packageRootDir(),
+      skillsHome: home,
+    });
+    expect(missing.length).toBeGreaterThan(0);
+
+    const { installed } = await installCursorSkills(missing.slice(0, 2), home);
+    expect(installed).toHaveLength(2);
+
+    for (const leaf of installed) {
+      const body = await readFile(
+        join(home, "agentkit", leaf, "SKILL.md"),
+        "utf8"
+      );
+      expect(body).toContain("name: agentkit-");
+    }
+
+    const stillMissing = await findMissingCursorSkills({
+      packageRoot: packageRootDir(),
+      skillsHome: home,
+    });
+    expect(stillMissing.map((skill) => skill.leafDir)).not.toContain(
+      installed[0]
+    );
+  });
+
+  it("treats an existing SKILL.md under agentkit/ as installed", async () => {
+    const home = await makeTempDir("agentkit-skills-present-");
+    const skills = await listShippedPackageSkills(packageRootDir());
+    const first = skills[0];
+    expect(first).toBeDefined();
+    const target = skillInstallPath(first!, home);
+    await mkdir(target, { recursive: true });
+    await writeFile(join(target, "SKILL.md"), "---\nname: x\n---\n");
+
+    const missing = await findMissingCursorSkills({
+      packageRoot: packageRootDir(),
+      skillsHome: home,
+    });
+    expect(missing.map((skill) => skill.leafDir)).not.toContain(first!.leafDir);
+  });
+
+  it("strips monorepo paths from installed SKILL.md", async () => {
+    const home = await makeTempDir("agentkit-skills-paths-");
+    const skills = await listShippedPackageSkills(packageRootDir());
+    const createAgent = skills.find((s) => s.leafDir === "create-agent");
+    expect(createAgent).toBeDefined();
+    await installCursorSkills([createAgent!], home);
+    const body = await readFile(
+      join(home, "agentkit", "create-agent", "SKILL.md"),
+      "utf8"
+    );
+    const frontmatter = body.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
+    expect(frontmatter).not.toContain("paths:");
+  });
+
+  it("removes orphan leaf dirs under agentkit/ and reports them", async () => {
+    const home = await makeTempDir("agentkit-skills-orphan-");
+    const skills = await listShippedPackageSkills(packageRootDir());
+    const first = skills[0]!;
+    await installCursorSkills([first], home);
+    const orphan = join(home, "agentkit", "removed-skill");
+    await mkdir(orphan, { recursive: true });
+    await writeFile(join(orphan, "SKILL.md"), "---\nname: x\n---\n");
+
+    const { removed } = await installCursorSkills(skills, home);
+    expect(removed).toEqual(["removed-skill"]);
+    await expect(readFile(join(orphan, "SKILL.md"), "utf8")).rejects.toThrow();
+  });
+});
+
+describe("offerInstallCursorSkills", () => {
+  it("skips when interactive is false", async () => {
+    const home = await makeTempDir("agentkit-skills-offer-");
+    const lines: string[] = [];
+    const result = await offerInstallCursorSkills({
+      interactive: false,
+      skillsHome: home,
+      packageRoot: packageRootDir(),
+      out: (text) => lines.push(text),
+    });
+    expect(result).toEqual({ installed: [], skipped: true });
+    expect(lines).toEqual([]);
+  });
+
+  it("installs after confirmation into the agentkit namespace", async () => {
+    const home = await makeTempDir("agentkit-skills-confirm-");
+    const lines: string[] = [];
+    const result = await offerInstallCursorSkills({
+      interactive: true,
+      skillsHome: home,
+      packageRoot: packageRootDir(),
+      confirm: async () => true,
+      out: (text) => lines.push(text),
+    });
+    expect(result.skipped).toBe(false);
+    expect(result.installed.length).toBeGreaterThan(0);
+    expect(lines.join("")).toContain("Installed");
+    expect(lines.join("")).toContain(
+      `  location: ${agentkitCursorSkillsDir(home)}`
+    );
+  });
+
+  it("overwrites existing skills on update", async () => {
+    const home = await makeTempDir("agentkit-skills-overwrite-");
+    const skills = await listShippedPackageSkills(packageRootDir());
+    const first = skills[0]!;
+    const target = skillInstallPath(first, home);
+    await mkdir(target, { recursive: true });
+    await writeFile(join(target, "SKILL.md"), "---\nname: stale\n---\nstale\n");
+
+    const lines: string[] = [];
+    const result = await offerInstallCursorSkills({
+      interactive: true,
+      skillsHome: home,
+      packageRoot: packageRootDir(),
+      confirm: async () => true,
+      out: (text) => lines.push(text),
+    });
+    expect(result.skipped).toBe(false);
+    expect(result.installed).toContain(first.leafDir);
+    expect(lines.join("")).toContain("Update");
+    expect(lines.join("")).toContain("overwrites");
+    const body = await readFile(join(target, "SKILL.md"), "utf8");
+    expect(body).toContain(`name: ${first.name}`);
+    expect(body).not.toContain("stale");
+  });
+
+  it("skips install when the user declines", async () => {
+    const home = await makeTempDir("agentkit-skills-decline-");
+    const lines: string[] = [];
+    const result = await offerInstallCursorSkills({
+      interactive: true,
+      skillsHome: home,
+      packageRoot: packageRootDir(),
+      confirm: async () => false,
+      out: (text) => lines.push(text),
+    });
+    expect(result).toEqual({ installed: [], skipped: true });
+    expect(lines.join("")).toContain(
+      `install-skills (${agentkitCursorSkillsDir(home)})`
+    );
+    const missing = await findMissingCursorSkills({
+      packageRoot: packageRootDir(),
+      skillsHome: home,
+    });
+    expect(missing.length).toBeGreaterThan(0);
+  });
+
+  it("skips install when the prompt goes unanswered", async () => {
+    const home = await makeTempDir("agentkit-skills-timeout-");
+    const lines: string[] = [];
+    const result = await offerInstallCursorSkills({
+      interactive: true,
+      skillsHome: home,
+      packageRoot: packageRootDir(),
+      confirm: async () => undefined,
+      out: (text) => lines.push(text),
+    });
+    expect(result).toEqual({ installed: [], skipped: true });
+    expect(lines.join("")).toContain("No answer");
+    expect(lines.join("")).toContain("install-skills");
+    const missing = await findMissingCursorSkills({
+      packageRoot: packageRootDir(),
+      skillsHome: home,
+    });
+    expect(missing.length).toBeGreaterThan(0);
+  });
+});
+
+describe("promptYesNo", () => {
+  // init prompts for login right after the skills offer, so a timed-out
+  // prompt has to leave the stream readable.
+  it("gives up when nobody answers, and the next prompt still reads", async () => {
+    const input = new PassThrough();
+    const timedOut = await promptYesNo("Install now?", {
+      defaultYes: true,
+      out: () => {},
+      timeoutMs: 20,
+      input,
+    });
+    expect(timedOut).toBeUndefined();
+    expect(input.listenerCount("data")).toBe(0);
+
+    const pending = promptYesNo("Sign in?", {
+      defaultYes: true,
+      out: () => {},
+      timeoutMs: 5_000,
+      input,
+    });
+    input.write("n\n");
+    expect(await pending).toBe(false);
+  });
+});
+
+describe("cursorSkillsHome", () => {
+  it("resolves the skills root and agentkit namespace", () => {
+    expect(cursorSkillsHome("/tmp/home")).toBe("/tmp/home/.cursor/skills");
+    expect(agentkitCursorSkillsDir("/tmp/home/.cursor/skills")).toBe(
+      "/tmp/home/.cursor/skills/agentkit"
+    );
+  });
+
+  it("uses homedir when HOME is empty", () => {
+    expect(cursorSkillsHome("")).toBe(join(homedir(), ".cursor", "skills"));
+  });
+});
+
+describe("prepareSkillMarkdownForCursorInstall", () => {
+  it("removes paths and rewrites monorepo doc links", () => {
+    const input = `---
+name: test
+paths:
+  - packages/agent-serve/**/*
+---
+See [\`docs/ab.md\`](../../docs/ab.md).
+`;
+    const out = prepareSkillMarkdownForCursorInstall(input);
+    expect(out).not.toContain("paths:");
+    expect(out).toContain("docs/ab.md in the @cursor/july package");
+  });
+});

package/src/internal/local-env.test.ts

@@ -0,0 +1,100 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { loadAgentLocalEnv } from "./local-env.js";
+
+const tempDirs: string[] = [];
+const setKeys: string[] = [];
+
+afterEach(async () => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir !== undefined) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  }
+  while (setKeys.length > 0) {
+    const key = setKeys.pop();
+    if (key !== undefined) {
+      delete process.env[key];
+    }
+  }
+});
+
+async function makeDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "agentkit-local-env-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("loadAgentLocalEnv", () => {
+  it("loads the root and immediate-child .env.local files", async () => {
+    const dir = await makeDir();
+    await writeFile(join(dir, ".env.local"), "LOCALENV_ROOT=root\n");
+    await mkdir(join(dir, "child-agent"));
+    await writeFile(
+      join(dir, "child-agent", ".env.local"),
+      "LOCALENV_CHILD=child\n"
+    );
+    await mkdir(join(dir, "node_modules"));
+    await writeFile(
+      join(dir, "node_modules", ".env.local"),
+      "LOCALENV_NODE_MODULES=nope\n"
+    );
+    setKeys.push("LOCALENV_ROOT", "LOCALENV_CHILD", "LOCALENV_NODE_MODULES");
+
+    const loaded = loadAgentLocalEnv(dir);
+
+    expect(loaded).toEqual([
+      join(dir, ".env.local"),
+      join(dir, "child-agent", ".env.local"),
+    ]);
+    expect(process.env.LOCALENV_ROOT).toBe("root");
+    expect(process.env.LOCALENV_CHILD).toBe("child");
+    expect(process.env.LOCALENV_NODE_MODULES).toBeUndefined();
+  });
+
+  it("never overrides real environment variables", async () => {
+    const dir = await makeDir();
+    await writeFile(join(dir, ".env.local"), "LOCALENV_PRECEDENCE=fromfile\n");
+    setKeys.push("LOCALENV_PRECEDENCE");
+    process.env.LOCALENV_PRECEDENCE = "fromreal";
+
+    loadAgentLocalEnv(dir);
+
+    expect(process.env.LOCALENV_PRECEDENCE).toBe("fromreal");
+  });
+
+  it("picks up a value edited since the previous load", async () => {
+    const dir = await makeDir();
+    await writeFile(join(dir, ".env.local"), "LOCALENV_ROTATED=first\n");
+    setKeys.push("LOCALENV_ROTATED");
+
+    loadAgentLocalEnv(dir);
+    expect(process.env.LOCALENV_ROTATED).toBe("first");
+
+    await writeFile(join(dir, ".env.local"), "LOCALENV_ROTATED=second\n");
+    loadAgentLocalEnv(dir);
+
+    expect(process.env.LOCALENV_ROTATED).toBe("second");
+  });
+
+  it("still lets real env win on a reload", async () => {
+    const dir = await makeDir();
+    await writeFile(join(dir, ".env.local"), "LOCALENV_REAL_WINS=fromfile\n");
+    setKeys.push("LOCALENV_REAL_WINS");
+    process.env.LOCALENV_REAL_WINS = "fromreal";
+
+    loadAgentLocalEnv(dir);
+    loadAgentLocalEnv(dir);
+
+    expect(process.env.LOCALENV_REAL_WINS).toBe("fromreal");
+  });
+
+  it("returns empty for directories without env files", async () => {
+    const dir = await makeDir();
+    expect(loadAgentLocalEnv(dir)).toEqual([]);
+    expect(loadAgentLocalEnv(join(dir, "missing"))).toEqual([]);
+  });
+});

package/src/internal/log-ring.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createLogRing } from "./log-ring.js";
+
+describe("createLogRing", () => {
+  it("forwards to the inner logger and retains entries", () => {
+    const seen: string[] = [];
+    const ring = createLogRing({ capacity: 10 });
+    const log = ring.wrap((line) => {
+      seen.push(line);
+    });
+    log("one");
+    log("two");
+    expect(seen).toEqual(["one", "two"]);
+    const all = ring.since(-1);
+    expect(all.map((e) => e.line)).toEqual(["one", "two"]);
+    expect(all[0]?.index).toBe(0);
+    expect(all[1]?.index).toBe(1);
+  });
+
+  it("respects capacity and since(after)", () => {
+    const ring = createLogRing({ capacity: 3 });
+    const log = ring.wrap(() => {});
+    log("a");
+    log("b");
+    log("c");
+    log("d");
+    expect(ring.since(-1).map((e) => e.line)).toEqual(["b", "c", "d"]);
+    expect(ring.since(1).map((e) => e.line)).toEqual(["c", "d"]);
+    expect(ring.since(99)).toEqual([]);
+  });
+});