feat(release): skip publishes for test-only changes

Author: vicary

.github/scripts/version.test.ts

@@ -11,6 +11,7 @@ import {
   applyBump,
   calculateVersion,
   findReleaseAs,
+  hasNonTestChanges,
   parseSemver,
 } from "./version.ts";
 
@@ -283,13 +284,40 @@ describe("parseSemver", () => {
   });
 });
 
+describe("hasNonTestChanges", () => {
+  it("returns false for only test files", () => {
+    assertEquals(
+      hasNonTestChanges([
+        ".github/scripts/version.test.ts",
+        "src/foo.test.ts",
+      ]),
+      false,
+    );
+  });
+
+  it("returns true when at least one non-test file is present", () => {
+    assertEquals(
+      hasNonTestChanges([
+        ".github/scripts/version.test.ts",
+        ".github/scripts/version.ts",
+      ]),
+      true,
+    );
+  });
+
+  it("returns false for an empty file list", () => {
+    assertEquals(hasNonTestChanges([]), false);
+  });
+});
+
 describe("calculateVersion", () => {
   const baseOpts = {
     currentVersion: "1.0.0",
     subjects: [],
     bodies: [],
     commitSha: "abc123def456",
     timestamp: "20260212091429",
+    changedFiles: ["src/mod.ts"],
     noGitTags: false,
   };
 
@@ -349,6 +377,26 @@ describe("calculateVersion", () => {
       });
       assertEquals(result, { skip: false, version: "0.6.0", tag: "latest" });
     });
+
+    it("skips when unreleased changes are only test files", () => {
+      const result = calculateVersion({
+        ...baseOpts,
+        subjects: ["feat: new feature"],
+        changedFiles: ["src/foo.test.ts", ".github/scripts/version.test.ts"],
+        eventName: "push",
+      });
+      assertEquals(result, { skip: true });
+    });
+
+    it("still releases when test and non-test files both changed", () => {
+      const result = calculateVersion({
+        ...baseOpts,
+        subjects: ["feat: new feature"],
+        changedFiles: ["src/foo.test.ts", "src/foo.ts"],
+        eventName: "push",
+      });
+      assertEquals(result, { skip: false, version: "1.1.0", tag: "latest" });
+    });
   });
 
   describe("pull_request events (canaries)", () => {
@@ -417,6 +465,16 @@ describe("calculateVersion", () => {
         assertEquals(result.version.includes("1234567."), true);
       }
     });
+
+    it("skips canary publish when unreleased changes are only test files", () => {
+      const result = calculateVersion({
+        ...baseOpts,
+        subjects: ["feat: feature"],
+        changedFiles: ["src/foo.test.ts"],
+        eventName: "pull_request",
+      });
+      assertEquals(result, { skip: true });
+    });
   });
 
   describe("noGitTags fallback", () => {

.github/scripts/version.ts

@@ -106,6 +106,11 @@ export function parseSemver(
   ];
 }
 
+/** Whether the changed paths include at least one non-test file. */
+export function hasNonTestChanges(changedFiles: string[]): boolean {
+  return changedFiles.some((file) => file && !file.endsWith(".test.ts"));
+}
+
 /**
  * Calculate the next version given all inputs.
  *
@@ -124,9 +129,15 @@ export function calculateVersion(opts: {
   commitSha: string;
   /** Timestamp string for canary suffix (e.g. "20260212091429"). */
   timestamp: string;
+  /** Files changed since the last release baseline. */
+  changedFiles: string[];
   /** Whether we fell back to npm (no git tags). */
   noGitTags: boolean;
 }): VersionResult {
+  if (!hasNonTestChanges(opts.changedFiles)) {
+    return { skip: true };
+  }
+
   const [major, minor, patch] = parseSemver(opts.currentVersion);
 
   // Check for Release-As override first
@@ -229,6 +240,7 @@ async function run(args: string[]): Promise<void> {
   let currentVersion: string;
   let subjects: string[];
   let bodies: string[];
+  let changedFiles: string[];
   let noGitTags: boolean;
 
   if (!latestTag) {
@@ -238,6 +250,8 @@ async function run(args: string[]): Promise<void> {
     currentVersion = npmVersion || "0.0.0";
     subjects = (await cmd("git", "log", "--format=%s")).split("\n");
     bodies = (await cmd("git", "log", "--format=%b")).split("\n");
+    changedFiles = (await cmd("git", "ls-tree", "-r", "--name-only", "HEAD"))
+      .split("\n");
     noGitTags = true;
   } else {
     currentVersion = latestTag.replace(/^v/, "");
@@ -253,6 +267,12 @@ async function run(args: string[]): Promise<void> {
       `${latestTag}..HEAD`,
       "--format=%b",
     )).split("\n");
+    changedFiles = (await cmd(
+      "git",
+      "diff",
+      "--name-only",
+      `${latestTag}..HEAD`,
+    )).split("\n");
     noGitTags = false;
   }
 
@@ -265,6 +285,7 @@ async function run(args: string[]): Promise<void> {
     eventName,
     commitSha,
     timestamp,
+    changedFiles,
     noGitTags,
   });
 

src/config.test.ts

@@ -1,5 +1,7 @@
 import { assertFalse, assertStrictEquals } from "jsr:@std/assert@^1.0.0";
 import { describe, it } from "jsr:@std/testing@^1.0.0/bdd";
+import { stub } from "jsr:@std/testing@^1.0.0/mock";
+import os from "node:os";
 import { join } from "node:path";
 import { loadConfig } from "./config.ts";
 import type { GraphitiConfig } from "./types/index.ts";
@@ -215,5 +217,106 @@ describe("config", () => {
         });
       });
     });
+
+    // --- legacy home fallback tests ---
+    //
+    // README documents a legacy fallback at ~/.config/opencode/.graphitirc (step 3 in
+    // lookup order).  These tests are deterministic regression tests that verify this
+    // exact path is read when no project-local or standard global config is found.
+    //
+    // The tests use an isolated fake home directory (via os.homedir() stub) so the
+    // real home directory is never touched.
+
+    it("loads ~/.config/opencode/.graphitirc as legacy fallback when no other config exists", async () => {
+      // Create an isolated fake home dir so the real ~ is never touched.
+      const fakeHome = await Deno.makeTempDir({ prefix: "graphiti_fakehome_" });
+      const legacyDir = join(fakeHome, ".config", "opencode");
+
+      try {
+        await Deno.mkdir(legacyDir, { recursive: true });
+        await Deno.writeTextFile(
+          join(legacyDir, ".graphitirc"),
+          JSON.stringify({
+            endpoint: "http://legacy-opencode.local/mcp",
+            driftThreshold: 0.8,
+            factStaleDays: 42,
+          }),
+        );
+
+        // Redirect os.homedir() for the duration of this test only.
+        // CWD is outside fakeHome so the upward walk never reaches it.
+        using _homedirStub = stub(os, "homedir", () => fakeHome);
+
+        await withTempDirAsCwd(() => {
+          const config = loadConfig();
+          assertConfigValues(config, {
+            endpoint: "http://legacy-opencode.local/mcp",
+            groupIdPrefix: "opencode", // default, not in file
+            driftThreshold: 0.8,
+            factStaleDays: 42,
+          });
+        });
+      } finally {
+        await Deno.remove(fakeHome, { recursive: true });
+      }
+    });
+
+    it("merges partial ~/.config/opencode/.graphitirc with defaults", async () => {
+      const fakeHome = await Deno.makeTempDir({ prefix: "graphiti_fakehome_" });
+      const legacyDir = join(fakeHome, ".config", "opencode");
+
+      try {
+        await Deno.mkdir(legacyDir, { recursive: true });
+        // Only override one field; remaining fields must come from DEFAULT_CONFIG.
+        await Deno.writeTextFile(
+          join(legacyDir, ".graphitirc"),
+          JSON.stringify({ endpoint: "http://partial-legacy.local/mcp" }),
+        );
+
+        using _homedirStub = stub(os, "homedir", () => fakeHome);
+
+        await withTempDirAsCwd(() => {
+          const config = loadConfig();
+          assertStrictEquals(
+            config.endpoint,
+            "http://partial-legacy.local/mcp",
+          );
+          assertStrictEquals(config.groupIdPrefix, "opencode"); // default
+          assertStrictEquals(config.driftThreshold, 0.5); // default
+          assertStrictEquals(config.factStaleDays, 30); // default
+        });
+      } finally {
+        await Deno.remove(fakeHome, { recursive: true });
+      }
+    });
+
+    it("project-local config takes precedence over ~/.config/opencode/.graphitirc", async () => {
+      const fakeHome = await Deno.makeTempDir({ prefix: "graphiti_fakehome_" });
+      const legacyDir = join(fakeHome, ".config", "opencode");
+
+      try {
+        await Deno.mkdir(legacyDir, { recursive: true });
+        await Deno.writeTextFile(
+          join(legacyDir, ".graphitirc"),
+          JSON.stringify({
+            endpoint: "http://legacy-should-be-ignored.local/mcp",
+          }),
+        );
+
+        using _homedirStub = stub(os, "homedir", () => fakeHome);
+
+        await withTempDir(async (projectDir) => {
+          await Deno.writeTextFile(
+            join(projectDir, ".graphitirc"),
+            JSON.stringify({ endpoint: "http://project-wins.local/mcp" }),
+          );
+
+          const config = loadConfig(projectDir);
+          assertStrictEquals(config.endpoint, "http://project-wins.local/mcp");
+        });
+      } finally {
+        await Deno.remove(fakeHome, { recursive: true });
+      }
+    });
   });
 });

src/config.ts

@@ -20,21 +20,34 @@ const GraphitiConfigSchema = z.object({
 /**
  * Load Graphiti configuration from JSONC files with defaults applied.
  *
- * When `directory` is provided, the search starts from that directory (no
- * upward traversal past it) so that a project-local `.graphitirc` or
- * `package.json#graphiti` key takes precedence over any global/home config.
- * If no config is found in the project directory the search falls back to a
- * global search (home directory and OS-level config locations).
+ * Lookup order:
+ *  1. `directory` (if provided): standard cosmiconfig search starting from that
+ *     directory (no upward traversal past it) — project-local `.graphitirc`,
+ *     `package.json#graphiti`, etc.
+ *  2. Standard global/home cosmiconfig locations discovered by walking upward
+ *     from CWD to the home directory (e.g. `~/.graphitirc`).
+ *  3. Legacy fallback: `~/.config/opencode/.graphitirc` — the path used by
+ *     earlier versions of the plugin.
  */
 export function loadConfig(directory?: string): GraphitiConfig {
-  const result = cosmiconfigSync("graphiti", {
+  const explorer = cosmiconfigSync("graphiti", {
     stopDir: os.homedir(),
     mergeSearchPlaces: true,
     cache: false,
-  }).search(directory) ??
-    cosmiconfigSync("graphiti", {
-      searchPlaces: [`${os.homedir()}/.graphitirc`],
-    }).search();
+  });
+
+  // Step 1 & 2: project-local search (with directory arg) or CWD upward walk.
+  const result = explorer.search(directory) ??
+    (() => {
+      // Step 3: legacy fallback — load the fixed path explicitly so that
+      // cosmiconfig's search-place joining does not mangle absolute paths.
+      const legacyPath = `${os.homedir()}/.config/opencode/.graphitirc`;
+      try {
+        return cosmiconfigSync("graphiti", { cache: false }).load(legacyPath);
+      } catch {
+        return null;
+      }
+    })();
 
   const merged = {
     ...DEFAULT_CONFIG,