gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/git-conflict-state.ts

@@ -0,0 +1,23 @@
+// Project/App: GSD-2
+// File Purpose: Detect unresolved Git conflict state before automation runs.
+
+import { execFileSync } from "node:child_process";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
+
+function splitZeroDelimited(output: string): string[] {
+  return output.split("\0").filter(Boolean);
+}
+
+export function listUnmergedGitPaths(basePath: string): string[] | null {
+  try {
+    const output = execFileSync("git", ["diff", "--name-only", "--diff-filter=U", "-z"], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+    });
+    return [...new Set(splitZeroDelimited(output))].sort();
+  } catch {
+    return null;
+  }
+}

package/src/resources/extensions/gsd/git-service.ts

@@ -17,6 +17,7 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { logWarning } from "./workflow-logger.js";
+import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 
 
 import {
@@ -123,6 +124,10 @@ export interface TurnGitActionResult {
   commitMessage?: string;
   snapshotLabel?: string;
   dirty?: boolean;
+  dirtyRepositories?: Record<string, boolean>;
+  commitMessages?: Record<string, string>;
+  commitErrors?: Record<string, string>;
+  skippedRepositories?: string[];
   error?: string;
 }
 
@@ -270,6 +275,30 @@ function isExcludedScopedPath(path: string, exclusions: readonly string[]): bool
   return false;
 }
 
+function submodulePathsFromLsFiles(output: string): Set<string> {
+  const submodulePaths = new Set<string>();
+  if (!output) return submodulePaths;
+
+  for (const line of output.split("\n")) {
+    const match = line.match(/^160000\s+\S+\s+\d+\t(.+)$/);
+    if (!match) continue;
+    submodulePaths.add(match[1].replace(/\\/g, "/").replace(/\/+$/, ""));
+  }
+  return submodulePaths;
+}
+
+function isInsideSubmodule(path: string, submodulePaths: ReadonlySet<string>): boolean {
+  const normalizedPath = path.replace(/\\/g, "/");
+  if (submodulePaths.has(normalizedPath)) return true;
+
+  let slashIndex = normalizedPath.lastIndexOf("/");
+  while (slashIndex > 0) {
+    if (submodulePaths.has(normalizedPath.slice(0, slashIndex))) return true;
+    slashIndex = normalizedPath.lastIndexOf("/", slashIndex - 1);
+  }
+  return false;
+}
+
 /**
  * Thrown when a slice merge hits code conflicts in non-.gsd files.
  * The working tree is left in a conflicted state (no reset) so the
@@ -364,6 +393,9 @@ export function readIntegrationBranch(basePath: string, milestoneId: string): st
   }
 }
 
+/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
+export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
+
 /**
  * Persist the integration branch for a milestone.
  *
@@ -374,14 +406,14 @@ export function readIntegrationBranch(basePath: string, milestoneId: string): st
  *
  * The file is committed immediately so the metadata is persisted in git.
  */
-/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
-export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
-
 export function writeIntegrationBranch(
   basePath: string,
   milestoneId: string,
   branch: string,
 ): void {
+  // Never persist milestone branches as integration targets.
+  // They are ephemeral execution branches and can cause self-diff corruption.
+  if (branch.startsWith("milestone/")) return;
   // Don't record slice branches as the integration target
   if (SLICE_BRANCH_RE.test(branch)) return;
   // Don't record quick-task branches — they are ephemeral and merge back
@@ -425,6 +457,10 @@ export interface IntegrationBranchResolution {
   reason: string;
 }
 
+function normalizeLocalBranchRef(branch: string): string {
+  return branch.replace(/^refs\/heads\//, "");
+}
+
 /**
  * Resolve a milestone's recorded integration branch into an actionable status.
  *
@@ -448,7 +484,14 @@ export function resolveMilestoneIntegrationBranch(
     };
   }
 
-  if (nativeBranchExists(basePath, recordedBranch)) {
+  const normalizedRecordedBranch = normalizeLocalBranchRef(recordedBranch);
+  const isRecordedMilestoneBranch = normalizedRecordedBranch.startsWith("milestone/");
+  const recordedBranchUsable = !isRecordedMilestoneBranch;
+  const recordedBranchStateMessage = isRecordedMilestoneBranch
+    ? `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} is invalid (milestone branches cannot be merge targets)`
+    : `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists`;
+
+  if (recordedBranchUsable && nativeBranchExists(basePath, recordedBranch)) {
     return {
       recordedBranch,
       effectiveBranch: recordedBranch,
@@ -467,7 +510,7 @@ export function resolveMilestoneIntegrationBranch(
         recordedBranch,
         effectiveBranch: configuredBranch,
         status: "fallback",
-        reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists; using configured git.main_branch "${configuredBranch}" instead.`,
+        reason: `${recordedBranchStateMessage}; using configured git.main_branch "${configuredBranch}" instead.`,
       };
     }
 
@@ -475,7 +518,7 @@ export function resolveMilestoneIntegrationBranch(
       recordedBranch,
       effectiveBranch: null,
       status: "missing",
-      reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists, and configured git.main_branch "${configuredBranch}" is unavailable.`,
+      reason: `${recordedBranchStateMessage}, and configured git.main_branch "${configuredBranch}" is unavailable.`,
     };
   }
 
@@ -486,7 +529,7 @@ export function resolveMilestoneIntegrationBranch(
         recordedBranch,
         effectiveBranch: detectedBranch,
         status: "fallback",
-        reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists; using detected fallback branch "${detectedBranch}" instead.`,
+        reason: `${recordedBranchStateMessage}; using detected fallback branch "${detectedBranch}" instead.`,
       };
     }
   } catch {
@@ -497,7 +540,7 @@ export function resolveMilestoneIntegrationBranch(
     recordedBranch,
     effectiveBranch: null,
     status: "missing",
-    reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists, and no safe fallback branch could be determined.`,
+    reason: `${recordedBranchStateMessage}, and no safe fallback branch could be determined.`,
   };
 }
 
@@ -764,6 +807,26 @@ export class GitServiceImpl {
       .filter(file => !nativeIsIgnored(this.basePath, file))
       .filter(file => !isExcludedScopedPath(file, allExclusions));
 
+    const scopedPaths: string[] = [];
+    const submodulePaths: string[] = [];
+    const repoSubmodules = submodulePathsFromLsFiles(
+      runGit(this.basePath, ["ls-files", "--stage"], { allowFailure: true }),
+    );
+    for (const path of normalized) {
+      if (isInsideSubmodule(path, repoSubmodules)) {
+        submodulePaths.push(path);
+      } else {
+        scopedPaths.push(path);
+      }
+    }
+    if (submodulePaths.length > 0) {
+      logWarning(
+        "engine",
+        `scoped stage: dropping ${submodulePaths.length} keyFile(s) inside git submodule(s): ${submodulePaths.join(", ")}`,
+        { file: "git-service.ts" },
+      );
+    }
+
     // Drop entries that don't exist on disk. The LLM occasionally lists files
     // it intended to write but didn't (or names them with wrong casing/path).
     // Pre-`b304f738b` `git add -A` swallowed these silently; the scoped
@@ -771,7 +834,7 @@ export class GitServiceImpl {
     // the whole commit fail (see #5500). Filter so valid paths still commit.
     const missing: string[] = [];
     const existing: string[] = [];
-    for (const path of normalized) {
+    for (const path of scopedPaths) {
       if (existsSync(join(this.basePath, path))) {
         existing.push(path);
       } else {
@@ -859,7 +922,19 @@ export class GitServiceImpl {
     const message = taskContext
       ? buildTaskCommitMessage(taskContext)
       : `chore: auto-commit after ${unitType}\n\nGSD-Unit: ${unitId}`;
-    nativeCommit(this.basePath, message, { allowEmpty: false });
+    try {
+      nativeCommit(this.basePath, message, { allowEmpty: false });
+    } catch (err) {
+      // Some pre-commit hooks intentionally rewrite files and fail the first
+      // commit to force a re-stage + retry.
+      if (!nativeHasChanges(this.basePath)) throw err;
+      const retriedScoped = taskContext
+        ? this.scopedStageTaskFiles(taskContext, extraExclusions)
+        : false;
+      if (!retriedScoped) this.smartStage(extraExclusions);
+      if (!nativeHasStagedChanges(this.basePath)) throw err;
+      nativeCommit(this.basePath, message, { allowEmpty: false });
+    }
 
     // Absorb any preceding gsd snapshot commits into this real commit.
     // Walk backwards from HEAD~1 counting consecutive snapshot subjects,
@@ -1153,28 +1228,97 @@ export function handleTurnGitActionError(action: TurnGitActionMode, err: unknown
   if (isInfrastructureError(err)) {
     throw err;
   }
+  const errorWithStreams = err as { stderr?: string; message?: string };
   return {
     action,
     status: "failed",
-    error: getErrorMessage(err),
+    error: errorWithStreams.stderr?.trim() || errorWithStreams.message || getErrorMessage(err),
   };
 }
 
+function collectRepositoryDirtyStatus(basePath: string): Record<string, boolean> {
+  const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+  const registry = createRepositoryRegistryFromPreferences(basePath, preferences);
+  const dirtyByRepository: Record<string, boolean> = {};
+  for (const repo of registry.repositories) {
+    try {
+      dirtyByRepository[repo.id] = runGit(repo.root, ["status", "--porcelain"]).length > 0;
+    } catch {
+      // Fallback preserves legacy behavior if explicit status probing fails.
+      dirtyByRepository[repo.id] = nativeHasChanges(repo.root);
+    }
+  }
+  return dirtyByRepository;
+}
+
+function runPerRepositoryCommitAction(args: {
+  basePath: string;
+  unitType: string;
+  unitId: string;
+  taskContext?: TaskCommitContext;
+  targetRepositories?: string[];
+}): {
+  commitMessages: Record<string, string>;
+  commitErrors: Record<string, string>;
+  skippedRepositories: string[];
+} {
+  const preferences = loadEffectiveGSDPreferences(args.basePath)?.preferences;
+  const registry = createRepositoryRegistryFromPreferences(args.basePath, preferences);
+  const repoIds = args.targetRepositories ?? ["project"];
+  const gitPrefs = preferences?.git ?? {};
+  const commitMessages: Record<string, string> = {};
+  const commitErrors: Record<string, string> = {};
+  const skippedRepositories: string[] = [];
+
+  for (const repoId of repoIds) {
+    const repo = registry.byId.get(repoId);
+    if (!repo) {
+      commitErrors[repoId] = `unknown repository target: ${repoId}`;
+      continue;
+    }
+    if (repo.commitPolicy === "skip") {
+      skippedRepositories.push(repo.id);
+      continue;
+    }
+
+    try {
+      const message =
+        new GitServiceImpl(repo.root, gitPrefs).autoCommit(
+          args.unitType,
+          args.unitId,
+          [],
+          args.taskContext,
+        ) ?? "";
+      if (message) {
+        commitMessages[repo.id] = message;
+      }
+    } catch (err) {
+      commitErrors[repo.id] = getErrorMessage(err);
+    }
+  }
+
+  return { commitMessages, commitErrors, skippedRepositories };
+}
+
 export function runTurnGitAction(args: {
   basePath: string;
   action: TurnGitActionMode;
   unitType: string;
   unitId: string;
   taskContext?: TaskCommitContext;
+  targetRepositories?: string[];
 }): TurnGitActionResult {
   try {
     // Force fresh working-tree status per turn; nativeHasChanges caches briefly.
     _resetHasChangesCache();
+    const dirtyRepositories = collectRepositoryDirtyStatus(args.basePath);
+    const dirty = Object.values(dirtyRepositories).some(Boolean);
     if (args.action === "status-only") {
       return {
         action: args.action,
         status: "ok",
-        dirty: nativeHasChanges(args.basePath),
+        dirty,
+        dirtyRepositories,
       };
     }
 
@@ -1186,16 +1330,38 @@ export function runTurnGitAction(args: {
         action: args.action,
         status: "ok",
         snapshotLabel: label,
-        dirty: nativeHasChanges(args.basePath),
+        dirty,
+        dirtyRepositories,
+      };
+    }
+
+    const repoCommitResult = runPerRepositoryCommitAction(args);
+    if (Object.keys(repoCommitResult.commitErrors).length > 0) {
+      return {
+        action: args.action,
+        status: "failed",
+        error: Object.entries(repoCommitResult.commitErrors)
+          .map(([repoId, msg]) => `${repoId}: ${msg}`)
+          .join("; "),
+        dirty,
+        dirtyRepositories,
+        commitMessages: repoCommitResult.commitMessages,
+        commitErrors: repoCommitResult.commitErrors,
+        skippedRepositories: repoCommitResult.skippedRepositories,
       };
     }
 
-    const commitMessage = git.autoCommit(args.unitType, args.unitId, [], args.taskContext) ?? undefined;
+    const primaryMessage =
+      repoCommitResult.commitMessages[args.targetRepositories?.[0] ?? "project"]
+      ?? Object.values(repoCommitResult.commitMessages)[0];
     return {
       action: args.action,
       status: "ok",
-      commitMessage,
-      dirty: nativeHasChanges(args.basePath),
+      commitMessage: primaryMessage,
+      dirty,
+      dirtyRepositories,
+      commitMessages: repoCommitResult.commitMessages,
+      skippedRepositories: repoCommitResult.skippedRepositories,
     };
   } catch (err) {
     return handleTurnGitActionError(args.action, err);