@bigking67/pi-67 0.10.12 → 0.10.14

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.10.14]
+
+- Refreshes the Git index stat cache for `settings.json` during
+  `update --repair` when Git reports `M settings.json` but `git diff` has no
+  real content changes, clearing the remaining Windows false-dirty state after
+  line-ending/runtime-state cleanup.
+
+## [0.10.13]
+
+- Normalizes `settings.json` BOM/CRLF line endings during `update --repair`
+  even when the runtime `lastChangelogVersion` marker is already absent,
+  clearing Windows Git EOL false-dirty states without changing provider,
+  model, theme, or other JSON content.
+
 ## [0.10.12]
 
 - Pins `settings.json` to LF line endings in `.gitattributes` while preserving

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigking67/pi-67",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "description": "Cross-platform manager CLI for the pi-67 Pi Coding Agent distribution.",
   "type": "module",
   "bin": {

package/scripts/check.mjs

@@ -9,7 +9,9 @@ import { parseCommandOptions, splitGlobalArgs } from "../src/lib/args.mjs";
 import { readExtensionRegistry, validateExtensionRegistry } from "../src/lib/extension-registry.mjs";
 import { buildPlanDecisions, classifyGitShort } from "../src/lib/update-plan.mjs";
 import {
+  migrateSettingsRuntimeState,
   mergeSettingsRuntimeMarkerIntoState,
+  refreshSettingsGitIndex,
   settingsRuntimeMarkerFromObject,
   stripSettingsRuntimeMarkerText,
 } from "../src/lib/settings-runtime-state.mjs";
@@ -406,6 +408,54 @@ function runSettingsRuntimeStateSelfTests() {
       state.runtimeMarkers.lastChangelogVersion.storage === "state.json",
     "settings runtime marker must migrate into state runtimeMarkers",
   );
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi67-settings-runtime-state-"));
+  const agentDir = path.join(tmpRoot, "agent");
+  const stateDir = path.join(tmpRoot, "state");
+  fs.mkdirSync(agentDir, { recursive: true });
+  fs.writeFileSync(path.join(agentDir, "settings.json"), "{\r\n  \"theme\": \"gruvbox-dark\"\r\n}\r\n", "utf8");
+  const lineEndingResult = migrateSettingsRuntimeState(
+    { agentDir, repoRoot: agentDir, stateDir },
+    { normalizeSettingsJson: true },
+  );
+  const normalizedSettings = fs.readFileSync(path.join(agentDir, "settings.json"), "utf8");
+  assert(lineEndingResult.markerFound === false, "line-ending normalization must not require runtime marker");
+  assert(lineEndingResult.settingsNormalized === true, "CRLF settings.json must be normalized under --normalize");
+  assert(
+    lineEndingResult.settingsNormalizeReasons.includes("line-endings"),
+    "settings normalization must classify CRLF as line-endings",
+  );
+  assert(
+    normalizedSettings === "{\n  \"theme\": \"gruvbox-dark\"\n}\n",
+    "settings line-ending normalization must preserve JSON content and indentation",
+  );
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+
+  if (spawnSync("git", ["--version"], { encoding: "utf8" }).status === 0) {
+    const gitRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi67-settings-index-refresh-"));
+    const gitStateDir = path.join(gitRoot, "state");
+    fs.writeFileSync(path.join(gitRoot, ".gitattributes"), "settings.json text eol=lf\n");
+    fs.writeFileSync(path.join(gitRoot, "settings.json"), "{\n  \"theme\": \"gruvbox-dark\"\n}\n");
+    for (const args of [
+      ["-C", gitRoot, "init", "-q"],
+      ["-C", gitRoot, "config", "user.email", "pi67-check@example.invalid"],
+      ["-C", gitRoot, "config", "user.name", "pi67-check"],
+      ["-C", gitRoot, "add", ".gitattributes", "settings.json"],
+      ["-C", gitRoot, "commit", "-q", "-m", "init"],
+    ]) {
+      const result = spawnSync("git", args, { encoding: "utf8" });
+      assert(result.status === 0, `git setup failed for settings index refresh self-test: git ${args.join(" ")}\n${result.stderr}`);
+    }
+    fs.writeFileSync(path.join(gitRoot, "settings.json"), "{\r\n  \"theme\": \"gruvbox-dark\"\r\n}\r\n");
+    const statusBefore = spawnSync("git", ["-C", gitRoot, "status", "--short", "--", "settings.json"], { encoding: "utf8" });
+    const diffBefore = spawnSync("git", ["-C", gitRoot, "diff", "--quiet", "--", "settings.json"], { encoding: "utf8" });
+    assert(statusBefore.stdout.includes("settings.json"), "settings index refresh self-test must start with false-dirty status");
+    assert(diffBefore.status === 0, "settings index refresh self-test must have no real content diff");
+    const refreshResult = refreshSettingsGitIndex({ agentDir: gitRoot, repoRoot: gitRoot, stateDir: gitStateDir });
+    const statusAfter = spawnSync("git", ["-C", gitRoot, "status", "--short", "--", "settings.json"], { encoding: "utf8" });
+    assert(refreshResult.refreshed === true, "settings index refresh must classify cleared false-dirty status");
+    assert(!statusAfter.stdout.trim(), `settings index refresh must clear false-dirty status\n${statusAfter.stdout}`);
+    fs.rmSync(gitRoot, { recursive: true, force: true });
+  }
 }
 
 function runUpdatePreflightMigrationSelfTests() {

package/src/commands/install.mjs

@@ -58,7 +58,10 @@ export async function installCommand(ctx, argv) {
       info("Migrated settings.json lastChangelogVersion to ignored state: ~/.pi/pi67/state.json");
     }
     if (runtimeState.settingsNormalized) {
-      info("Normalized settings.json by removing runtime-only lastChangelogVersion.");
+      info("Normalized settings.json runtime marker/line endings.");
+    }
+    if (runtimeState.gitIndexRefreshed) {
+      info("Refreshed settings.json Git index stat cache.");
     }
     if (runtimeState.gitFilterInstalled) {
       info("Installed local git clean filter for future settings.json runtime markers.");

package/src/commands/update.mjs

@@ -100,7 +100,10 @@ function reportSettingsRuntimeStateMigration(ctx, options = {}) {
     info(`${phase}${dryRun ? "would migrate" : "Migrated"} settings.json lastChangelogVersion to ignored state: ~/.pi/pi67/state.json`);
   }
   if (result.settingsNormalized) {
-    info(`${phase}${dryRun ? "would normalize" : "Normalized"} settings.json by removing runtime-only lastChangelogVersion.`);
+    info(`${phase}${dryRun ? "would normalize" : "Normalized"} settings.json runtime marker/line endings.`);
+  }
+  if (result.gitIndexRefreshed) {
+    info(`${phase}${dryRun ? "would refresh" : "Refreshed"} settings.json Git index stat cache.`);
   }
   if (result.gitFilterInstalled) {
     info(`${phase}${dryRun ? "would install" : "Installed"} local git clean filter for future settings.json runtime markers.`);

package/src/lib/settings-runtime-state.mjs

@@ -67,6 +67,9 @@ export function migrateSettingsRuntimeState(ctx, options = {}) {
     markerValue: "",
     stateWritten: false,
     settingsNormalized: false,
+    settingsNormalizeReasons: [],
+    gitIndexRefreshed: false,
+    gitIndexRefreshSkipped: "",
     gitFilterInstalled: false,
     skipped: [],
     errors: [],
@@ -75,10 +78,12 @@ export function migrateSettingsRuntimeState(ctx, options = {}) {
   if (!fs.existsSync(settingsPath)) {
     result.skipped.push("settings.json missing");
   } else {
+    let rawSettingsText = "";
     let settingsText = "";
     let settings = null;
     try {
-      settingsText = fs.readFileSync(settingsPath, "utf8").replace(/^\uFEFF/, "");
+      rawSettingsText = fs.readFileSync(settingsPath, "utf8");
+      settingsText = rawSettingsText.replace(/^\uFEFF/, "");
       settings = JSON.parse(settingsText);
     } catch (error) {
       result.errors.push(`settings.json is not valid JSON: ${error.message}`);
@@ -95,14 +100,28 @@ export function migrateSettingsRuntimeState(ctx, options = {}) {
       }
       if (normalizeSettingsJson) {
         const normalizedText = stableSettingsJson(stripSettingsRuntimeMarker(settings));
-        if (normalizedText !== settingsText) {
+        if (normalizedText !== rawSettingsText) {
           if (!dryRun) {
             fs.writeFileSync(settingsPath, normalizedText, "utf8");
           }
           result.settingsNormalized = true;
+          result.settingsNormalizeReasons.push("runtime-marker");
+          if (normalizeSettingsTextLineEndings(rawSettingsText) !== rawSettingsText) {
+            result.settingsNormalizeReasons.push("line-endings");
+          }
         }
       }
     } else {
+      if (normalizeSettingsJson && settings) {
+        const normalizedText = normalizeSettingsTextLineEndings(rawSettingsText);
+        if (normalizedText !== rawSettingsText) {
+          if (!dryRun) {
+            fs.writeFileSync(settingsPath, normalizedText, "utf8");
+          }
+          result.settingsNormalized = true;
+          result.settingsNormalizeReasons.push("line-endings");
+        }
+      }
       result.skipped.push("settings.json runtime marker absent");
     }
   }
@@ -114,6 +133,76 @@ export function migrateSettingsRuntimeState(ctx, options = {}) {
     if (filterResult.error) result.errors.push(filterResult.error);
   }
 
+  if (normalizeSettingsJson) {
+    const refreshResult = refreshSettingsGitIndex(ctx, { dryRun });
+    result.gitIndexRefreshed = refreshResult.refreshed;
+    result.gitIndexRefreshSkipped = refreshResult.skipped;
+    if (refreshResult.error) result.errors.push(refreshResult.error);
+  }
+
+  return result;
+}
+
+export function normalizeSettingsTextLineEndings(text) {
+  return String(text || "")
+    .replace(/^\uFEFF/, "")
+    .replace(/\r\n?/g, "\n");
+}
+
+export function refreshSettingsGitIndex(ctx, options = {}) {
+  const result = {
+    refreshed: false,
+    skipped: "",
+    error: "",
+  };
+  if (options.dryRun) {
+    result.refreshed = true;
+    return result;
+  }
+  if (!isGitRepo(ctx.repoRoot)) {
+    result.skipped = "repo root is not a git checkout";
+    return result;
+  }
+
+  const settingsPath = path.join(ctx.agentDir, "settings.json");
+  if (!fs.existsSync(settingsPath)) {
+    result.skipped = "settings.json missing";
+    return result;
+  }
+
+  const relativePath = path.relative(ctx.repoRoot, settingsPath);
+  if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    result.skipped = "settings.json is outside repo root";
+    return result;
+  }
+  const gitPath = relativePath.split(path.sep).join("/");
+
+  const statusBefore = captureCommand("git", ["-C", ctx.repoRoot, "status", "--short", "--", gitPath]);
+  if (!statusBefore.ok) {
+    result.skipped = "could not inspect settings.json git status before index refresh";
+    return result;
+  }
+  if (!statusBefore.stdout.trim()) {
+    result.skipped = "settings.json git index already fresh";
+    return result;
+  }
+
+  const diffBefore = captureCommand("git", ["-C", ctx.repoRoot, "diff", "--quiet", "--", gitPath]);
+  if (diffBefore.status !== 0) {
+    result.skipped = "settings.json has real content diff; index refresh left it visible";
+    return result;
+  }
+
+  const refresh = captureCommand("git", ["-C", ctx.repoRoot, "update-index", "--refresh", "--", gitPath]);
+
+  const statusAfter = captureCommand("git", ["-C", ctx.repoRoot, "status", "--short", "--", gitPath]);
+  if (statusAfter.ok && !statusAfter.stdout.trim()) {
+    result.refreshed = true;
+  } else if (!refresh.ok) {
+    result.error = refresh.stderr || refresh.error || "failed to refresh settings.json git index";
+  } else {
+    result.skipped = "settings.json still appears dirty after git index refresh";
+  }
   return result;
 }
 

package/src/tools/settings-runtime-state-filter.mjs

@@ -51,7 +51,10 @@ function printHuman(result) {
     console.log("PASS settings.json runtime marker is already absent");
   }
   if (result.settingsNormalized) {
-    console.log("PASS normalized settings.json by removing runtime-only lastChangelogVersion");
+    console.log("PASS normalized settings.json runtime marker/line endings");
+  }
+  if (result.gitIndexRefreshed) {
+    console.log("PASS refreshed settings.json Git index stat cache");
   }
   if (result.gitFilterInstalled) {
     console.log("PASS installed local git clean filter for settings.json runtime marker");