convex 1.44.0 → 1.45.0

package/src/cli/lib/aiFiles/prompt.test.ts

@@ -1,202 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import type { Context } from "../../../bundler/context.js";
-import {
-  AGENTS_MD_END_MARKER,
-  AGENTS_MD_START_MARKER,
-} from "../../codegen_templates/agentsmd.js";
-
-const { mockPromptYesNo } = vi.hoisted(() => {
-  return { mockPromptYesNo: vi.fn() };
-});
-
-vi.mock("@sentry/node", () => ({
-  captureException: vi.fn(),
-  captureMessage: vi.fn(),
-}));
-
-vi.mock("../../../bundler/log.js", () => ({
-  logMessage: vi.fn(),
-  logFinishedStep: vi.fn(),
-}));
-
-vi.mock("../versionApi.js", () => ({
-  downloadGuidelines: vi.fn(async () => "prompt test guidelines content"),
-  fetchAgentSkillsCatalog: vi.fn(async () => ({
-    kind: "ok",
-    data: {
-      latestRepoSha: "prompt-test-agent-skills-sha",
-      skills: [],
-    },
-  })),
-  fetchAgentSkillsSha: vi.fn(async () => "prompt-test-sha"),
-  getVersion: vi.fn(async () => ({
-    kind: "ok",
-    data: {
-      message: null,
-      guidelinesHash: "prompt-test-guidelines-hash",
-      agentSkillsSha: "prompt-test-agent-skills-sha",
-      disableSkillsCli: false,
-      disableSkillsCliMessage: null,
-    },
-  })),
-}));
-
-vi.mock("child_process", () => ({
-  default: {
-    spawn: vi.fn(() => ({
-      stdout: { on: vi.fn() },
-      stderr: { on: vi.fn() },
-      on: (event: string, cb: (code: number) => void) => {
-        if (event === "close") cb(0);
-      },
-    })),
-  },
-}));
-
-vi.mock("../utils/prompts.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../utils/prompts.js")>();
-  return {
-    ...actual,
-    promptYesNo: mockPromptYesNo,
-  };
-});
-
-import { attemptSetupAiFiles } from "./index.js";
-
-function makeTmpDir(): string {
-  return fs.mkdtempSync(`${os.tmpdir()}${path.sep}`);
-}
-
-const fakeCtx: Context = {
-  fs: {
-    readFile: (p: string) => fs.readFileSync(p, { encoding: "utf8" }),
-    exists: (p: string) => fs.existsSync(p),
-    readdir: (p: string) => fs.readdirSync(p),
-    stat: (p: string) => fs.statSync(p),
-    readUtf8File: (p: string) => fs.readFileSync(p, { encoding: "utf8" }),
-    lstat: (p: string) => fs.lstatSync(p),
-  } as unknown as Context["fs"],
-  deprecationMessagePrinted: false,
-  crash: async (args) => {
-    throw new Error(args.printedMessage ?? "crash");
-  },
-  registerCleanup: () => "handle",
-  removeCleanup: (() => null) as unknown as Context["removeCleanup"],
-  bigBrainAuth: () => null,
-  _updateBigBrainAuth: () => {},
-};
-
-describe("maybeSetupAiFiles interactive prompt", () => {
-  let tmpDir: string;
-  let convexDir: string;
-  let originalIsTTY: boolean | undefined;
-
-  const aiDir = () => path.join(convexDir, "_generated", "ai");
-  const guidelinesPath = () => path.join(aiDir(), "guidelines.md");
-  const statePath = () => path.join(aiDir(), "ai-files.state.json");
-  const projectConfigPath = () => path.join(tmpDir, "convex.json");
-
-  beforeEach(() => {
-    tmpDir = makeTmpDir();
-    convexDir = path.join(tmpDir, "convex");
-    fs.mkdirSync(convexDir, { recursive: true });
-    fs.writeFileSync(path.join(convexDir, "schema.ts"), "");
-    originalIsTTY = process.stdin.isTTY;
-    process.stdin.isTTY = true;
-    mockPromptYesNo.mockResolvedValue(true);
-  });
-
-  afterEach(() => {
-    process.stdin.isTTY = originalIsTTY!;
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-    vi.unstubAllEnvs();
-    vi.clearAllMocks();
-  });
-
-  test("user accepts prompt: AI files are installed", async () => {
-    mockPromptYesNo.mockResolvedValue(true);
-
-    await attemptSetupAiFiles({ ctx: fakeCtx, convexDir, projectDir: tmpDir });
-
-    expect(fs.existsSync(guidelinesPath())).toBe(true);
-    expect(fs.existsSync(statePath())).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(true);
-    expect(fs.readFileSync(guidelinesPath(), "utf8")).toBe(
-      "prompt test guidelines content",
-    );
-  });
-
-  test("user declines prompt: no config and no AI files are written", async () => {
-    mockPromptYesNo.mockResolvedValue(false);
-
-    await attemptSetupAiFiles({ ctx: fakeCtx, convexDir, projectDir: tmpDir });
-
-    expect(fs.existsSync(guidelinesPath())).toBe(false);
-    expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(false);
-    expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(false);
-    expect(fs.existsSync(projectConfigPath())).toBe(false);
-  });
-
-  test("non-interactive terminal skips the prompt and does not install AI files", async () => {
-    process.stdin.isTTY = false;
-
-    await attemptSetupAiFiles({ ctx: fakeCtx, convexDir, projectDir: tmpDir });
-
-    expect(fs.existsSync(guidelinesPath())).toBe(false);
-    expect(fs.existsSync(statePath())).toBe(false);
-    expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(false);
-    expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(false);
-    expect(fs.existsSync(projectConfigPath())).toBe(false);
-  });
-
-  test("existing state file updates AI files without prompting", async () => {
-    const stateDir = path.join(convexDir, "_generated", "ai");
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(stateDir, "ai-files.state.json"),
-      JSON.stringify(
-        {
-          guidelinesHash: "hash",
-          agentsMdSectionHash: "hash",
-          claudeMdHash: "hash",
-          agentSkillsSha: "sha",
-        },
-        null,
-        2,
-      ),
-    );
-
-    await attemptSetupAiFiles({ ctx: fakeCtx, convexDir, projectDir: tmpDir });
-
-    expect(fs.existsSync(path.join(stateDir, "ai-files.state.json"))).toBe(
-      true,
-    );
-    expect(fs.existsSync(guidelinesPath())).toBe(true);
-    expect(fs.readFileSync(guidelinesPath(), "utf8")).toBe(
-      "prompt test guidelines content",
-    );
-  });
-
-  test("existing AGENTS.md managed section rebuilds state without prompting", async () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "AGENTS.md"),
-      [
-        "# Team notes",
-        "",
-        AGENTS_MD_START_MARKER,
-        "Managed section",
-        AGENTS_MD_END_MARKER,
-        "",
-      ].join("\n"),
-    );
-
-    await attemptSetupAiFiles({ ctx: fakeCtx, convexDir, projectDir: tmpDir });
-
-    expect(fs.existsSync(statePath())).toBe(true);
-    expect(fs.existsSync(guidelinesPath())).toBe(true);
-  });
-});

package/src/cli/lib/aiFiles/state.test.ts

@@ -1,305 +0,0 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
-import * as Sentry from "@sentry/node";
-import { promises as fs } from "fs";
-import {
-  aiFilesStateSchema,
-  attemptReadAiState,
-  hasAiState,
-  readAiStateOrDefault,
-  writeAiState,
-} from "./state.js";
-
-vi.mock("@sentry/node", () => ({
-  captureException: vi.fn(),
-  captureMessage: vi.fn(),
-}));
-
-vi.mock("fs", () => ({
-  promises: {
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-    mkdir: vi.fn().mockResolvedValue(undefined),
-  },
-}));
-
-const mockFs = vi.mocked(fs);
-const mockCaptureException = vi.mocked(Sentry.captureException);
-
-const dummyConvexDir = "/tmp/test-project/convex";
-
-describe("aiFilesStateSchema", () => {
-  test("accepts a fully populated valid state object", () => {
-    const result = aiFilesStateSchema.safeParse({
-      guidelinesHash: "abc123",
-      agentsMdSectionHash: "def456",
-      claudeMdHash: "ghi789",
-      agentSkillsSha: "deadbeef",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  test("accepts null hashes", () => {
-    const result = aiFilesStateSchema.safeParse({
-      guidelinesHash: null,
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  test("strips legacy local skill tracking fields", () => {
-    const result = aiFilesStateSchema.safeParse({
-      version: 2,
-      guidelinesHash: "abc",
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-      installedSkillNames: ["convex-migrations"],
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data).toEqual({
-        guidelinesHash: "abc",
-        agentsMdSectionHash: null,
-        claudeMdHash: null,
-        agentSkillsSha: null,
-      });
-    }
-  });
-
-  test("rejects a number where a string hash is expected", () => {
-    const result = aiFilesStateSchema.safeParse({
-      guidelinesHash: 123,
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects missing required fields", () => {
-    const result = aiFilesStateSchema.safeParse({
-      guidelinesHash: "abc",
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("attemptReadAiState", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("returns no-file when the state file does not exist", async () => {
-    mockFs.readFile.mockRejectedValue(
-      Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-    );
-
-    const result = await attemptReadAiState(dummyConvexDir);
-
-    expect(result).toEqual({ kind: "no-file" });
-    expect(mockCaptureException).not.toHaveBeenCalled();
-  });
-
-  test("returns no-file when the state file is empty", async () => {
-    mockFs.readFile.mockResolvedValueOnce("");
-
-    const result = await attemptReadAiState(dummyConvexDir);
-
-    expect(result).toEqual({ kind: "no-file" });
-    expect(mockCaptureException).not.toHaveBeenCalled();
-  });
-
-  test("throws when reading the state file fails for reasons other than not found", async () => {
-    const error = Object.assign(new Error("EACCES"), { code: "EACCES" });
-    mockFs.readFile.mockRejectedValueOnce(error);
-
-    await expect(attemptReadAiState(dummyConvexDir)).rejects.toBe(error);
-    expect(mockCaptureException).not.toHaveBeenCalled();
-  });
-
-  test("returns ok with parsed state", async () => {
-    mockFs.readFile.mockResolvedValueOnce(
-      JSON.stringify({
-        version: 1,
-        guidelinesHash: "abc",
-        agentsMdSectionHash: "def",
-        claudeMdHash: null,
-        agentSkillsSha: null,
-      }),
-    );
-
-    const result = await attemptReadAiState(dummyConvexDir);
-
-    expect(result).toEqual({
-      kind: "ok",
-      state: {
-        guidelinesHash: "abc",
-        agentsMdSectionHash: "def",
-        claudeMdHash: null,
-        agentSkillsSha: null,
-      },
-    });
-  });
-
-  test("strips legacy tracking fields when reading older state files", async () => {
-    mockFs.readFile.mockResolvedValueOnce(
-      JSON.stringify({
-        version: 2,
-        guidelinesHash: "abc",
-        agentsMdSectionHash: "def",
-        claudeMdHash: null,
-        agentSkillsSha: "skills-sha",
-        installedSkillNames: ["convex-migrations"],
-      }),
-    );
-
-    const result = await attemptReadAiState(dummyConvexDir);
-
-    expect(result).toEqual({
-      kind: "ok",
-      state: {
-        guidelinesHash: "abc",
-        agentsMdSectionHash: "def",
-        claudeMdHash: null,
-        agentSkillsSha: "skills-sha",
-      },
-    });
-  });
-
-  test("returns parse-error and captures exception when JSON is invalid", async () => {
-    mockFs.readFile.mockResolvedValueOnce("not valid json {{{}");
-
-    const result = await attemptReadAiState(dummyConvexDir);
-
-    expect(result.kind).toBe("parse-error");
-    expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  test("returns parse-error and captures exception when schema validation fails", async () => {
-    mockFs.readFile.mockResolvedValueOnce(
-      JSON.stringify({
-        guidelinesHash: 99,
-        agentsMdSectionHash: null,
-      }),
-    );
-
-    const result = await attemptReadAiState(dummyConvexDir);
-
-    expect(result.kind).toBe("parse-error");
-    expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error));
-  });
-});
-
-describe("readAiStateOrDefault", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("returns default state when no state file exists", async () => {
-    mockFs.readFile.mockRejectedValue(
-      Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-    );
-
-    const result = await readAiStateOrDefault(dummyConvexDir);
-
-    expect(result).toEqual({
-      guidelinesHash: null,
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    });
-  });
-
-  test("returns default state on parse error", async () => {
-    mockFs.readFile.mockResolvedValueOnce("not valid json {{{}");
-
-    const result = await readAiStateOrDefault(dummyConvexDir);
-
-    expect(result).toEqual({
-      guidelinesHash: null,
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    });
-    expect(mockCaptureException).toHaveBeenCalled();
-  });
-
-  test("returns parsed state when state file exists", async () => {
-    const stored = {
-      guidelinesHash: "abc",
-      agentsMdSectionHash: "def",
-      claudeMdHash: null,
-      agentSkillsSha: "deadbeef",
-    };
-    mockFs.readFile.mockResolvedValueOnce(JSON.stringify(stored));
-
-    const result = await readAiStateOrDefault(dummyConvexDir);
-
-    expect(result).toEqual(stored);
-  });
-});
-
-describe("hasAiState", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("returns false when state file does not exist", async () => {
-    mockFs.readFile.mockRejectedValue(
-      Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-    );
-
-    const result = await hasAiState(dummyConvexDir);
-
-    expect(result).toBe(false);
-    expect(mockCaptureException).not.toHaveBeenCalled();
-  });
-
-  test("returns true when a valid state file exists", async () => {
-    mockFs.readFile.mockResolvedValueOnce(
-      JSON.stringify({
-        guidelinesHash: "abc",
-        agentsMdSectionHash: "def",
-        claudeMdHash: null,
-        agentSkillsSha: null,
-      }),
-    );
-
-    const result = await hasAiState(dummyConvexDir);
-
-    expect(result).toBe(true);
-  });
-
-  test("returns false and captures exception when the state file is invalid", async () => {
-    mockFs.readFile.mockResolvedValueOnce("not valid json {{{}");
-
-    const result = await hasAiState(dummyConvexDir);
-
-    expect(result).toBe(false);
-    expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error));
-  });
-});
-
-describe("writeAiState", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("writes state file", async () => {
-    mockFs.writeFile.mockResolvedValue(undefined);
-
-    const state = {
-      guidelinesHash: "abc",
-      agentsMdSectionHash: "def",
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    };
-
-    await writeAiState({ state, convexDir: dummyConvexDir });
-
-    expect(mockFs.writeFile).toHaveBeenCalledTimes(1);
-    expect(mockFs.writeFile).toHaveBeenCalledWith(
-      expect.stringContaining("ai-files.state.json"),
-      JSON.stringify(state, null, 2) + "\n",
-      "utf8",
-    );
-  });
-});

package/src/cli/lib/aiFiles/utils.test.ts

@@ -1,50 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { attemptReadFile } from "./utils.js";
-
-describe("attemptReadFile", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(`${os.tmpdir()}${path.sep}`);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test("returns content when the file has text", async () => {
-    const filePath = path.join(tmpDir, "content.txt");
-    fs.writeFileSync(filePath, "hello");
-
-    const result = await attemptReadFile(filePath);
-
-    expect(result).toEqual({ kind: "content", content: "hello" });
-  });
-
-  test("returns empty when the file exists but has no contents", async () => {
-    const filePath = path.join(tmpDir, "empty.txt");
-    fs.writeFileSync(filePath, "");
-
-    const result = await attemptReadFile(filePath);
-
-    expect(result).toEqual({ kind: "empty" });
-  });
-
-  test("returns not-found when the file does not exist", async () => {
-    const filePath = path.join(tmpDir, "missing.txt");
-
-    const result = await attemptReadFile(filePath);
-
-    expect(result).toEqual({ kind: "not-found" });
-  });
-
-  test("throws when fs.readFile fails for another reason", async () => {
-    const dirPath = path.join(tmpDir, "nested-dir");
-    fs.mkdirSync(dirPath);
-
-    await expect(attemptReadFile(dirPath)).rejects.toThrow();
-  });
-});

package/src/cli/lib/codegen.test.ts

@@ -1,49 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { oneoffContext, Context } from "../../bundler/context.js";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { cleanupStaleGeneratedEntries, doInitConvexFolder } from "./codegen.js";
-
-describe("codegen", () => {
-  let tmpDir: string;
-  let ctx: Context;
-
-  beforeEach(async () => {
-    ctx = await oneoffContext({
-      url: undefined,
-      adminKey: undefined,
-      envFile: undefined,
-    });
-    tmpDir = fs.mkdtempSync(`${os.tmpdir()}${path.sep}`);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test("writes README.md when initializing a new functions directory", async () => {
-    const functionsPath = path.join(tmpDir, "convex");
-    await doInitConvexFolder(ctx, functionsPath);
-
-    expect(ctx.fs.exists(path.join(functionsPath, "README.md"))).toBe(true);
-    expect(ctx.fs.exists(path.join(functionsPath, "tsconfig.json"))).toBe(true);
-  });
-
-  test("preserves convex/_generated/ai while deleting stale generated files", () => {
-    const codegenDir = path.join(tmpDir, "_generated");
-    ctx.fs.mkdir(codegenDir, { recursive: true, allowExisting: true });
-    ctx.fs.writeUtf8File(path.join(codegenDir, "server.js"), "export {};");
-    ctx.fs.writeUtf8File(path.join(codegenDir, "stale.js"), "export {};");
-    const aiDir = path.join(codegenDir, "ai");
-    ctx.fs.mkdir(aiDir, { recursive: true, allowExisting: true });
-    ctx.fs.writeUtf8File(path.join(aiDir, "ai-files.state.json"), "{}");
-
-    cleanupStaleGeneratedEntries(ctx, codegenDir, ["server.js"]);
-
-    expect(ctx.fs.exists(path.join(codegenDir, "server.js"))).toBe(true);
-    expect(ctx.fs.exists(path.join(codegenDir, "stale.js"))).toBe(false);
-    expect(ctx.fs.exists(aiDir)).toBe(true);
-    expect(ctx.fs.exists(path.join(aiDir, "ai-files.state.json"))).toBe(true);
-  });
-});