convex 1.34.1 → 1.35.0

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

@@ -1,460 +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,
-  hasAiFilesConfig,
-  readAiConfig,
-  writeAiConfig,
-  writeAiEnabledToProjectConfig,
-} from "./config.js";
-
-vi.mock("@sentry/node", () => ({
-  captureException: vi.fn(),
-  captureMessage: vi.fn(),
-}));
-
-vi.mock("fs", () => ({
-  promises: {
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-  },
-}));
-
-const mockFs = vi.mocked(fs);
-const mockCaptureException = vi.mocked(Sentry.captureException);
-
-const dummyProjectDir = "/tmp/test-project";
-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",
-      installedSkillNames: ["convex-migrations", "convex-perf-review"],
-    });
-    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("applies default for installedSkillNames when absent", () => {
-    const result = aiFilesStateSchema.safeParse({
-      guidelinesHash: "abc",
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.installedSkillNames).toEqual([]);
-    }
-  });
-
-  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("readAiConfig", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("returns null when the file does not exist", async () => {
-    mockFs.readFile.mockRejectedValue(
-      Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-    );
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBeNull();
-    expect(mockCaptureException).not.toHaveBeenCalled();
-  });
-
-  test("returns parsed state with enabled=true when convex.json is missing", async () => {
-    mockFs.readFile
-      .mockRejectedValueOnce(
-        Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-      )
-      .mockResolvedValueOnce(
-        JSON.stringify({
-          guidelinesHash: "abc",
-          agentsMdSectionHash: "def",
-          claudeMdHash: null,
-          agentSkillsSha: null,
-        }),
-      );
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toEqual({
-      guidelinesHash: "abc",
-      agentsMdSectionHash: "def",
-      claudeMdHash: null,
-      agentSkillsSha: null,
-      installedSkillNames: [],
-      enabled: true,
-    });
-  });
-
-  test("returns empty disabled config when state file is missing and convex.json disables nags", async () => {
-    mockFs.readFile
-      .mockResolvedValueOnce(
-        JSON.stringify({ aiFiles: { disableStalenessMessage: true } }),
-      )
-      .mockRejectedValueOnce(
-        Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-      );
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toEqual({
-      guidelinesHash: null,
-      agentsMdSectionHash: null,
-      claudeMdHash: null,
-      agentSkillsSha: null,
-      installedSkillNames: [],
-      enabled: false,
-    });
-  });
-
-  test("returns null and captures exception when JSON is invalid", async () => {
-    mockFs.readFile
-      .mockResolvedValueOnce(
-        JSON.stringify({ aiFiles: { disableStalenessMessage: false } }),
-      )
-      .mockResolvedValueOnce("not valid json {{{}");
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBeNull();
-    expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  test("returns null and captures exception when schema validation fails", async () => {
-    mockFs.readFile
-      .mockResolvedValueOnce(
-        JSON.stringify({ aiFiles: { disableStalenessMessage: false } }),
-      )
-      .mockResolvedValueOnce(
-        JSON.stringify({
-          guidelinesHash: 99,
-          agentsMdSectionHash: null,
-        }),
-      );
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBeNull();
-    expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  test("reads enabled=false from legacy disableStalenessMessage field for backward compat", async () => {
-    const stored = {
-      guidelinesHash: "abc",
-      agentsMdSectionHash: "def",
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    };
-    mockFs.readFile
-      .mockResolvedValueOnce(
-        JSON.stringify({ aiFiles: { disableStalenessMessage: true } }),
-      )
-      .mockResolvedValueOnce(JSON.stringify(stored));
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toEqual({
-      ...stored,
-      installedSkillNames: [],
-      enabled: false,
-    });
-  });
-
-  test("enabled: true takes precedence over legacy disableStalenessMessage: true", async () => {
-    const stored = {
-      guidelinesHash: "abc",
-      agentsMdSectionHash: "def",
-      claudeMdHash: null,
-      agentSkillsSha: null,
-    };
-    mockFs.readFile
-      .mockResolvedValueOnce(
-        JSON.stringify({
-          aiFiles: { enabled: true, disableStalenessMessage: true },
-        }),
-      )
-      .mockResolvedValueOnce(JSON.stringify(stored));
-
-    const result = await readAiConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toEqual({
-      ...stored,
-      installedSkillNames: [],
-      enabled: true,
-    });
-  });
-});
-
-describe("hasAiFilesConfig", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("returns false when neither convex.json nor state file exists", async () => {
-    mockFs.readFile.mockRejectedValue(
-      Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-    );
-
-    const result = await hasAiFilesConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBe(false);
-    expect(mockCaptureException).not.toHaveBeenCalled();
-  });
-
-  test("returns true when convex.json disables staleness messages", async () => {
-    mockFs.readFile.mockResolvedValueOnce(
-      JSON.stringify({ aiFiles: { disableStalenessMessage: true } }),
-    );
-
-    const result = await hasAiFilesConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBe(true);
-  });
-
-  test("returns true when a valid state file exists", async () => {
-    mockFs.readFile
-      .mockRejectedValueOnce(
-        Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-      )
-      .mockResolvedValueOnce(
-        JSON.stringify({
-          guidelinesHash: "abc",
-          agentsMdSectionHash: "def",
-          claudeMdHash: null,
-          agentSkillsSha: null,
-        }),
-      );
-
-    const result = await hasAiFilesConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBe(true);
-  });
-
-  test("returns false and captures exception when the state file is invalid", async () => {
-    mockFs.readFile
-      .mockRejectedValueOnce(
-        Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
-      )
-      .mockResolvedValueOnce("not valid json {{{}");
-
-    const result = await hasAiFilesConfig({
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(result).toBe(false);
-    expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error));
-  });
-});
-
-describe("writeAiConfig", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("writes state file and does not persist enabled=true by default", async () => {
-    mockFs.writeFile.mockResolvedValue(undefined);
-
-    const config = {
-      enabled: true,
-      guidelinesHash: "abc",
-      agentsMdSectionHash: "def",
-      claudeMdHash: null,
-      agentSkillsSha: null,
-      installedSkillNames: ["convex-migrations"],
-    };
-
-    await writeAiConfig({
-      config,
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(mockFs.writeFile).toHaveBeenCalledTimes(1);
-    expect(mockFs.writeFile).toHaveBeenCalledWith(
-      expect.stringContaining("ai-files.state.json"),
-      JSON.stringify(
-        {
-          guidelinesHash: "abc",
-          agentsMdSectionHash: "def",
-          claudeMdHash: null,
-          agentSkillsSha: null,
-          installedSkillNames: ["convex-migrations"],
-        },
-        null,
-        2,
-      ) + "\n",
-      "utf8",
-    );
-  });
-
-  test("persists enabled=true when requested explicitly", async () => {
-    mockFs.writeFile.mockResolvedValue(undefined);
-    mockFs.readFile.mockResolvedValue("{}");
-
-    await writeAiConfig({
-      config: {
-        enabled: true,
-        guidelinesHash: null,
-        agentsMdSectionHash: null,
-        claudeMdHash: null,
-        agentSkillsSha: null,
-        installedSkillNames: [],
-      },
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-      options: { persistEnabledPreference: "always" },
-    });
-
-    expect(mockFs.writeFile).toHaveBeenNthCalledWith(
-      2,
-      expect.stringContaining("convex.json"),
-      JSON.stringify(
-        {
-          $schema: "node_modules/convex/schemas/convex.schema.json",
-          aiFiles: { enabled: true },
-        },
-        null,
-        2,
-      ) + "\n",
-      "utf8",
-    );
-  });
-
-  test("persists enabled=false to convex.json by default", async () => {
-    mockFs.writeFile.mockResolvedValue(undefined);
-    mockFs.readFile.mockResolvedValue("{}");
-
-    await writeAiConfig({
-      config: {
-        enabled: false,
-        guidelinesHash: null,
-        agentsMdSectionHash: null,
-        claudeMdHash: null,
-        agentSkillsSha: null,
-        installedSkillNames: [],
-      },
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-    });
-
-    expect(mockFs.writeFile).toHaveBeenCalledTimes(2);
-    expect(mockFs.writeFile).toHaveBeenNthCalledWith(
-      2,
-      expect.stringContaining("convex.json"),
-      expect.stringContaining('"enabled": false'),
-      "utf8",
-    );
-  });
-
-  test("never writes to convex.json when persistEnabledPreference is 'never'", async () => {
-    mockFs.writeFile.mockResolvedValue(undefined);
-
-    await writeAiConfig({
-      config: {
-        enabled: false,
-        guidelinesHash: null,
-        agentsMdSectionHash: null,
-        claudeMdHash: null,
-        agentSkillsSha: null,
-        installedSkillNames: [],
-      },
-      projectDir: dummyProjectDir,
-      convexDir: dummyConvexDir,
-      options: { persistEnabledPreference: "never" },
-    });
-
-    expect(mockFs.writeFile).toHaveBeenCalledTimes(1);
-    expect(mockFs.writeFile).toHaveBeenCalledWith(
-      expect.stringContaining("ai-files.state.json"),
-      expect.any(String),
-      "utf8",
-    );
-  });
-});
-
-describe("writeAiEnabledToProjectConfig", () => {
-  beforeEach(() => vi.clearAllMocks());
-  afterEach(() => vi.resetAllMocks());
-
-  test("writes enabled=false to convex.json and drops legacy disableStalenessMessage", async () => {
-    mockFs.readFile.mockResolvedValue(
-      JSON.stringify({ aiFiles: { disableStalenessMessage: true } }),
-    );
-    mockFs.writeFile.mockResolvedValue(undefined);
-
-    await writeAiEnabledToProjectConfig({
-      projectDir: dummyProjectDir,
-      enabled: false,
-    });
-
-    expect(mockFs.writeFile).toHaveBeenCalledTimes(1);
-    const written = mockFs.writeFile.mock.calls[0][1] as string;
-    const parsed = JSON.parse(written);
-    expect(parsed.aiFiles.enabled).toBe(false);
-    expect(parsed.aiFiles.disableStalenessMessage).toBeUndefined();
-  });
-});

package/src/cli/lib/aiFiles/config.ts

@@ -1,188 +0,0 @@
-import * as Sentry from "@sentry/node";
-// Use raw fs (not ctx.fs) so these operations run asynchronously and don't
-// interfere with the file-watcher used by `convex dev`.
-// eslint-disable-next-line no-restricted-imports
-import { promises as fs } from "fs";
-import path from "path";
-import { z } from "zod";
-import { aiFilesStatePathForConvexDir } from "./paths.js";
-import { iife, readFileSafe } from "./utils.js";
-
-export const aiFilesStateSchema = z.object({
-  guidelinesHash: z.string().nullable(),
-  agentsMdSectionHash: z.string().nullable(),
-  claudeMdHash: z.string().nullable(),
-  // Commit SHA from get-convex/agent-skills that was current when skills were
-  // last installed. Used to detect when newer skills are available.
-  agentSkillsSha: z.string().nullable(),
-  // Names of skills installed by `npx skills add`, used by `remove` to
-  // only remove Convex-managed skills.
-  installedSkillNames: z.array(z.string()).default([]),
-});
-
-const aiFilesProjectConfigSchema = z
-  .object({
-    aiFiles: z
-      .object({
-        // `enabled` is the canonical field. When present it takes full
-        // precedence - `enabled: true` will re-enable even if the legacy
-        // disableStalenessMessage field is still `true` in the file.
-        enabled: z.boolean().optional(),
-        // @deprecated - use `enabled` instead. Read for backward compat;
-        // new writes always emit `enabled` and drop this key.
-        disableStalenessMessage: z.boolean().optional(),
-      })
-      .default({}),
-  })
-  .passthrough();
-
-type AiFilesState = z.infer<typeof aiFilesStateSchema>;
-export type AiFilesConfig = AiFilesState & {
-  enabled: boolean;
-};
-
-const EMPTY_AI_STATE: AiFilesState = {
-  guidelinesHash: null,
-  agentsMdSectionHash: null,
-  claudeMdHash: null,
-  agentSkillsSha: null,
-  installedSkillNames: [],
-};
-
-async function readAiEnabledFromProjectConfig(
-  projectDir: string,
-): Promise<boolean> {
-  const raw = await readFileSafe(path.join(projectDir, "convex.json"));
-  if (raw === null) return true;
-  try {
-    const parsed = aiFilesProjectConfigSchema.parse(JSON.parse(raw));
-    // `enabled` takes full precedence when explicitly set.
-    if (parsed.aiFiles.enabled !== undefined) return parsed.aiFiles.enabled;
-    // Legacy `disableStalenessMessage` - invert it.
-    return !(parsed.aiFiles.disableStalenessMessage ?? false);
-  } catch (err) {
-    Sentry.captureException(err);
-    return true;
-  }
-}
-
-export async function writeAiEnabledToProjectConfig({
-  projectDir,
-  enabled,
-}: {
-  projectDir: string;
-  enabled: boolean;
-}): Promise<void> {
-  const filePath = path.join(projectDir, "convex.json");
-  const existing = await iife(async () => {
-    try {
-      return JSON.parse(await fs.readFile(filePath, "utf8")) as unknown;
-    } catch {
-      return {} as unknown;
-    }
-  });
-  const base =
-    existing !== null &&
-    typeof existing === "object" &&
-    !Array.isArray(existing)
-      ? (existing as Record<string, unknown>)
-      : {};
-  const aiFilesValue =
-    base.aiFiles !== null &&
-    typeof base.aiFiles === "object" &&
-    !Array.isArray(base.aiFiles)
-      ? (base.aiFiles as Record<string, unknown>)
-      : {};
-  const { $schema, ...rest } = base;
-  // Remove legacy keys on every write.
-  const { disableStalenessMessage: _legacy, ...restAiFiles } = aiFilesValue;
-  const next: Record<string, unknown> = {
-    $schema: $schema ?? "node_modules/convex/schemas/convex.schema.json",
-    ...rest,
-    aiFiles: { ...restAiFiles, enabled },
-  };
-  await fs.writeFile(filePath, JSON.stringify(next, null, 2) + "\n", "utf8");
-}
-
-export async function readAiConfig({
-  projectDir,
-  convexDir,
-}: {
-  projectDir: string;
-  convexDir: string;
-}): Promise<AiFilesConfig | null> {
-  const enabled = await readAiEnabledFromProjectConfig(projectDir);
-  const rawState = await readFileSafe(aiFilesStatePathForConvexDir(convexDir));
-  if (rawState === null) {
-    // No state file means AI files are not installed, unless the user has
-    // explicitly disabled in convex.json.
-    return !enabled ? { ...EMPTY_AI_STATE, enabled } : null;
-  }
-  try {
-    const state = aiFilesStateSchema.parse(JSON.parse(rawState));
-    return { ...state, enabled };
-  } catch (err) {
-    Sentry.captureException(err);
-    return null;
-  }
-}
-
-export async function hasAiFilesConfig({
-  projectDir,
-  convexDir,
-}: {
-  projectDir: string;
-  convexDir: string;
-}): Promise<boolean> {
-  if (!(await readAiEnabledFromProjectConfig(projectDir))) {
-    return true;
-  }
-  try {
-    const rawState = await fs.readFile(
-      aiFilesStatePathForConvexDir(convexDir),
-      "utf8",
-    );
-    aiFilesStateSchema.parse(JSON.parse(rawState));
-    return true;
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
-      Sentry.captureException(err);
-    }
-    return false;
-  }
-}
-
-export async function writeAiConfig({
-  config,
-  projectDir,
-  convexDir,
-  options,
-}: {
-  config: AiFilesConfig;
-  projectDir: string;
-  convexDir: string;
-  options?: { persistEnabledPreference?: "ifFalse" | "always" | "never" };
-}): Promise<void> {
-  const state = aiFilesStateSchema.parse({
-    guidelinesHash: config.guidelinesHash,
-    agentsMdSectionHash: config.agentsMdSectionHash,
-    claudeMdHash: config.claudeMdHash,
-    agentSkillsSha: config.agentSkillsSha,
-    installedSkillNames: config.installedSkillNames,
-  });
-  await fs.writeFile(
-    aiFilesStatePathForConvexDir(convexDir),
-    JSON.stringify(state, null, 2) + "\n",
-    "utf8",
-  );
-
-  const persistMode = options?.persistEnabledPreference ?? "ifFalse";
-  if (
-    persistMode === "always" ||
-    (persistMode === "ifFalse" && !config.enabled)
-  )
-    await writeAiEnabledToProjectConfig({
-      projectDir,
-      enabled: config.enabled,
-    });
-}

package/src/values/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read(//Users/ianmacartney/src/convex-core/npm-packages/convex/**)",
-      "Bash(npx vitest:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}