@celilo/cli 0.16.1 → 0.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.16.1",
+  "version": "0.16.2",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -60,7 +60,7 @@
     "@celilo/capabilities": "^0.9.1",
     "@celilo/cli-display": "^0.1.9",
     "@celilo/core": "^0.3.0",
-    "@celilo/event-bus": "^0.1.9",
+    "@celilo/event-bus": "^0.1.10",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/module/packaging/release-metadata.test.ts

@@ -1,5 +1,14 @@
-import { describe, expect, test } from 'bun:test';
-import { type GitCommandRunner, buildReleaseMetadata, collectGitInfo } from './release-metadata';
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  type GitCommandRunner,
+  buildReleaseMetadata,
+  collectGitInfo,
+  makeRealGitRunner,
+} from './release-metadata';
 
 describe('buildReleaseMetadata', () => {
   test('produces a stable shape from injected inputs', () => {
@@ -77,7 +86,7 @@ describe('collectGitInfo', () => {
     expect(calls).toEqual([
       ['rev-parse', 'HEAD'],
       ['rev-parse', '--abbrev-ref', 'HEAD'],
-      ['status', '--porcelain'],
+      ['status', '--porcelain', '--', '.'],
     ]);
   });
 
@@ -101,3 +110,68 @@ describe('collectGitInfo', () => {
     expect(collectGitInfo('/tmp/x', run).dirty).toBe(true);
   });
 });
+
+/**
+ * Recurrence gate for #544, against a REAL git repo rather than a fake runner.
+ *
+ * The tests above pin the argv `collectGitInfo` constructs. That is what let the
+ * bug live: they asserted which command was built, never what it concluded, so
+ * they stayed green while the function reported the whole repository's dirt for
+ * every module. A fake `GitCommandRunner` cannot catch this at all — the defect
+ * IS git's real scoping behavior, which a stub by definition does not model.
+ *
+ * So this drives the real `makeRealGitRunner()` against a real checkout. Delete
+ * the `-- .` pathspec and the first test here fails; that is the whole point.
+ */
+describe('collectGitInfo scopes dirt to sourceDir (#544, real git)', () => {
+  let repo: string;
+  let moduleDir: string;
+  const git = (args: string[], cwd: string) =>
+    execFileSync('git', args, { cwd, encoding: 'utf-8' });
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), 'celilo-gitinfo-'));
+    moduleDir = join(repo, 'modules', 'probe');
+    mkdirSync(moduleDir, { recursive: true });
+    writeFileSync(join(moduleDir, 'manifest.yml'), 'id: probe\n');
+    writeFileSync(join(repo, 'bun.lock'), 'lockfile v1\n');
+
+    git(['init', '-q'], repo);
+    git(['config', 'user.email', 'test@celilo.test'], repo);
+    git(['config', 'user.name', 'Test'], repo);
+    git(['add', '-A'], repo);
+    git(['commit', '-qm', 'init'], repo);
+  });
+
+  afterEach(() => rmSync(repo, { recursive: true, force: true }));
+
+  test('a tracked file rewritten OUTSIDE the module does not make it dirty', () => {
+    // Exactly what broke the release: `bun install` rewrites the tracked root
+    // `bun.lock` between module publishes. The module itself is untouched.
+    writeFileSync(join(repo, 'bun.lock'), 'lockfile v1\nrewritten by bun install\n');
+
+    expect(collectGitInfo(moduleDir, makeRealGitRunner()).dirty).toBe(false);
+  });
+
+  test("a sibling module's dirt does not make this module dirty", () => {
+    const sibling = join(repo, 'modules', 'other');
+    mkdirSync(sibling, { recursive: true });
+    writeFileSync(join(sibling, 'manifest.yml'), 'id: other\n');
+
+    expect(collectGitInfo(moduleDir, makeRealGitRunner()).dirty).toBe(false);
+  });
+
+  test("the module's OWN dirt still blocks the publish", () => {
+    // The control. Scoping must not have simply disabled the check — this is
+    // the case the guard exists for, and it must still fire.
+    writeFileSync(join(moduleDir, 'manifest.yml'), 'id: probe\nversion: 9.9.9\n');
+
+    expect(collectGitInfo(moduleDir, makeRealGitRunner()).dirty).toBe(true);
+  });
+
+  test('an untracked file inside the module still blocks the publish', () => {
+    writeFileSync(join(moduleDir, 'stray.txt'), 'oops\n');
+
+    expect(collectGitInfo(moduleDir, makeRealGitRunner()).dirty).toBe(true);
+  });
+});

package/src/module/packaging/release-metadata.ts

@@ -129,7 +129,17 @@ export function collectGitInfo(sourceDir: string, run: GitCommandRunner): GitInf
   // `git status --porcelain` prints one line per modified/untracked file.
   // Empty output = clean. Null (command failure) is treated as not-dirty
   // because we don't want to falsely block a publish.
-  const status = run(['status', '--porcelain'], sourceDir);
+  //
+  // The `-- .` pathspec is load-bearing (#544). `git status` reports the WHOLE
+  // repository regardless of cwd, so passing `sourceDir` as cwd scoped nothing:
+  // every caller asks about one module, and got back the dirt of all of them
+  // plus the repo root. The release pipeline runs `bun install` between module
+  // publishes, which rewrites the tracked `bun.lock` at the root — so modules
+  // 1..N published fine and the next one failed with "Working tree at
+  // modules/<clean-module> has uncommitted changes", naming a directory that
+  // was clean and sending you to inspect it. Order-dependent, so it looked
+  // like a random module failing.
+  const status = run(['status', '--porcelain', '--', '.'], sourceDir);
   const dirty = status !== null && status.length > 0;
 
   return {