@gitgov/core 2.7.1 → 2.7.2

package/dist/src/fs.d.ts

@@ -1248,13 +1248,19 @@ declare class FsWorktreeSyncStateModule implements ISyncStateModule {
     getWorktreePath(): string;
     /** [WTSYNC-A1..A6] Ensures worktree exists and is healthy */
     ensureWorktree(): Promise<void>;
+    /**
+     * [WTSYNC-A7] Remove .gitignore from state branch if it exists.
+     * The worktree module filters files in code (shouldSyncFile()), not via .gitignore.
+     * Legacy state branches initialized by FsSyncState may have a .gitignore — remove it.
+     */
+    private removeLegacyGitignore;
     /** Check worktree health */
     private checkWorktreeHealth;
     /** Remove worktree cleanly */
     private removeWorktree;
-    /** [WTSYNC-B1..B14] Push local state to remote */
+    /** [WTSYNC-B1..B16] Push local state to remote */
     pushState(options: SyncStatePushOptions): Promise<SyncStatePushResult>;
-    /** [WTSYNC-C1..C8] Pull remote state */
+    /** [WTSYNC-C1..C9] Pull remote state */
     pullState(options?: SyncStatePullOptions): Promise<SyncStatePullResult>;
     /** [WTSYNC-D1..D7] Resolve rebase conflict */
     resolveConflict(options: SyncStateResolveOptions): Promise<SyncStateResolveResult>;
@@ -1280,6 +1286,12 @@ declare class FsWorktreeSyncStateModule implements ISyncStateModule {
     private execGit;
     /** Execute git command in worktree context (throws on non-zero exit) */
     private execInWorktree;
+    /**
+     * [WTSYNC-B16] Check if local gitgov-state has commits not present on remote.
+     * Returns { ahead: true } if local has unpushed commits or remote branch doesn't exist.
+     * Also returns { remoteExists } to let caller decide whether reconciliation is needed.
+     */
+    private isLocalAheadOfRemote;
     /** Calculate file delta (uncommitted changes in worktree) */
     private calculateFileDelta;
     /** [WTSYNC-B4/B9/B10/B11] Stage only syncable files from delta (adds, mods, and deletions) */

package/dist/src/fs.js

@@ -7646,7 +7646,7 @@ var FsWorktreeSyncStateModule = class {
     this.gitgovPath = path9__default.join(this.worktreePath, ".gitgov");
   }
   // ═══════════════════════════════════════════════
-  // Section A: Worktree Management (WTSYNC-A1..A6)
+  // Section A: Worktree Management (WTSYNC-A1..A7)
   // ═══════════════════════════════════════════════
   /** [WTSYNC-A4] Returns the worktree path */
   getWorktreePath() {
@@ -7657,6 +7657,7 @@ var FsWorktreeSyncStateModule = class {
     const health = await this.checkWorktreeHealth();
     if (health.healthy) {
       logger7.debug("Worktree is healthy");
+      await this.removeLegacyGitignore();
       return;
     }
     if (health.exists && !health.healthy) {
@@ -7674,6 +7675,26 @@ var FsWorktreeSyncStateModule = class {
         error instanceof Error ? error : void 0
       );
     }
+    await this.removeLegacyGitignore();
+  }
+  /**
+   * [WTSYNC-A7] Remove .gitignore from state branch if it exists.
+   * The worktree module filters files in code (shouldSyncFile()), not via .gitignore.
+   * Legacy state branches initialized by FsSyncState may have a .gitignore — remove it.
+   */
+  async removeLegacyGitignore() {
+    const gitignorePath = path9__default.join(this.worktreePath, ".gitignore");
+    if (!existsSync(gitignorePath)) return;
+    logger7.info("Removing legacy .gitignore from state branch");
+    try {
+      await this.execInWorktree(["rm", ".gitignore"]);
+      await this.execInWorktree(["commit", "-m", "gitgov: remove legacy .gitignore (filtering is in code)"]);
+    } catch {
+      try {
+        await promises.unlink(gitignorePath);
+      } catch {
+      }
+    }
   }
   /** Check worktree health */
   async checkWorktreeHealth() {
@@ -7719,9 +7740,9 @@ var FsWorktreeSyncStateModule = class {
     }
   }
   // ═══════════════════════════════════════════════
-  // Section B: Push Operations (WTSYNC-B1..B14)
+  // Section B: Push Operations (WTSYNC-B1..B16)
   // ═══════════════════════════════════════════════
-  /** [WTSYNC-B1..B14] Push local state to remote */
+  /** [WTSYNC-B1..B16] Push local state to remote */
   async pushState(options) {
     const { actorId, dryRun = false, force = false } = options;
     const log = (msg) => logger7.debug(`[pushState] ${msg}`);
@@ -7749,11 +7770,53 @@ var FsWorktreeSyncStateModule = class {
     const delta = rawDelta.filter((f) => shouldSyncFile2(f.file));
     log(`Delta: ${delta.length} syncable files (${rawDelta.length} total)`);
     if (delta.length === 0) {
+      const { ahead: aheadOfRemote, remoteExists } = await this.isLocalAheadOfRemote();
+      if (!aheadOfRemote) {
+        return {
+          success: true,
+          filesSynced: 0,
+          sourceBranch: options.sourceBranch ?? "current",
+          commitHash: null,
+          commitMessage: null,
+          conflictDetected: false
+        };
+      }
+      log("No uncommitted changes but local is ahead of remote \u2014 pushing existing commits");
+      if (remoteExists && !force) {
+        try {
+          await this.execInWorktree(["pull", "--rebase", "origin", this.stateBranchName]);
+        } catch (err) {
+          if (await this.isRebaseInProgress()) {
+            const affectedFiles = await this.getConflictedFiles();
+            return {
+              success: false,
+              filesSynced: 0,
+              sourceBranch: options.sourceBranch ?? "current",
+              commitHash: null,
+              commitMessage: null,
+              conflictDetected: true,
+              conflictInfo: {
+                type: "rebase_conflict",
+                affectedFiles,
+                message: "Rebase conflict during push reconciliation (local ahead, no uncommitted changes)",
+                resolutionSteps: [
+                  `Edit conflicted files in ${this.worktreePath}/.gitgov/`,
+                  'Run `gitgov sync resolve --reason "..."` to finalize'
+                ]
+              },
+              error: "Rebase conflict during push reconciliation"
+            };
+          }
+          throw err;
+        }
+      }
+      await this.execInWorktree(["push", "origin", this.stateBranchName]);
+      const currentHead = (await this.execInWorktree(["rev-parse", "HEAD"])).trim();
       return {
         success: true,
         filesSynced: 0,
         sourceBranch: options.sourceBranch ?? "current",
-        commitHash: null,
+        commitHash: currentHead,
         commitMessage: null,
         conflictDetected: false
       };
@@ -7848,9 +7911,9 @@ var FsWorktreeSyncStateModule = class {
     return result;
   }
   // ═══════════════════════════════════════════════
-  // Section C: Pull Operations (WTSYNC-C1..C8)
+  // Section C: Pull Operations (WTSYNC-C1..C9)
   // ═══════════════════════════════════════════════
-  /** [WTSYNC-C1..C8] Pull remote state */
+  /** [WTSYNC-C1..C9] Pull remote state */
   async pullState(options) {
     const { forceReindex = false, force = false } = options ?? {};
     const log = (msg) => logger7.debug(`[pullState] ${msg}`);
@@ -8276,6 +8339,33 @@ var FsWorktreeSyncStateModule = class {
   async execInWorktree(args, options) {
     return this.execGit(["-C", this.worktreePath, ...args], options);
   }
+  /**
+   * [WTSYNC-B16] Check if local gitgov-state has commits not present on remote.
+   * Returns { ahead: true } if local has unpushed commits or remote branch doesn't exist.
+   * Also returns { remoteExists } to let caller decide whether reconciliation is needed.
+   */
+  async isLocalAheadOfRemote() {
+    try {
+      await this.execGit(["ls-remote", "--exit-code", "origin", this.stateBranchName]);
+    } catch {
+      return { ahead: true, remoteExists: false };
+    }
+    try {
+      await this.execInWorktree(["fetch", "origin", this.stateBranchName]);
+    } catch {
+      return { ahead: false, remoteExists: true };
+    }
+    try {
+      const count = (await this.execInWorktree([
+        "rev-list",
+        `origin/${this.stateBranchName}..HEAD`,
+        "--count"
+      ])).trim();
+      return { ahead: parseInt(count, 10) > 0, remoteExists: true };
+    } catch {
+      return { ahead: true, remoteExists: true };
+    }
+  }
   /** Calculate file delta (uncommitted changes in worktree) */
   async calculateFileDelta() {
     try {