@promptbook/cli 0.114.0-49 → 0.114.0-50

package/src/cli/cli-commands/common/workspaceRepository.ts

@@ -1,17 +1,13 @@
-import { execFile } from 'child_process';
+import { spawn } from 'child_process';
 import { lstat, realpath } from 'fs/promises';
 import { dirname, join } from 'path';
 import { spaceTrim } from 'spacetrim';
-import { promisify } from 'util';
 import { EnvironmentMismatchError } from '../../../errors/EnvironmentMismatchError';
 import { NotAllowed } from '../../../errors/NotAllowed';
 import { loadPromptsModule } from '../../common/loadPromptsModule';
 import type { NormalizedQuestionsCliOptions } from './questionsCliOptions';
 import { resolveProjectDirectory } from './projectCliOptions';
 
-/** Shell-free Git execution, also usable from the packaged CLI. */
-const EXECUTE_FILE = promisify(execFile);
-
 /**
  * Resolved project directory and its enclosing working tree. Project artifacts belong to `projectPath`;
  * Git paths and synchronization belong to `repositoryRoot`, which may be an enclosing monorepo.
@@ -212,15 +208,67 @@ async function $assertNoBrokenRepositoryMetadata(projectPath: string, repository
     }
 }
 
-/** Executes Git without a shell, optional index locks, or credential prompts. */
-async function $runWorkspaceGit(projectPath: string, argumentsList: ReadonlyArray<string>): Promise<string> {
-    const result = await EXECUTE_FILE('git', [...argumentsList], {
-        cwd: projectPath,
-        env: { ...process.env, LC_ALL: 'C', GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0' },
-        windowsHide: true,
-        maxBuffer: 8 * 1024 * 1024,
+/**
+ * Executes Git without a shell, optional index locks, or credential prompts, retaining raw output boundaries.
+ * Drains both output streams without execFile's fixed buffer limit so large repository listings remain complete.
+ * @private shared Git discovery and commit-scope inspection
+ */
+export async function $runWorkspaceGit(
+    projectPath: string,
+    argumentsList: ReadonlyArray<string>,
+    options?: {
+        readonly env?: Record<string, string>;
+        readonly signal?: AbortSignal;
+        readonly input?: string | Buffer;
+    },
+): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', [...argumentsList], {
+            cwd: projectPath,
+            env: { ...process.env, LC_ALL: 'C', GIT_OPTIONAL_LOCKS: '0', GIT_TERMINAL_PROMPT: '0', ...options?.env },
+            windowsHide: true,
+            signal: options?.signal,
+        });
+        const stdoutChunks: string[] = [];
+        const stderrChunks: string[] = [];
+        let processError: Error | undefined;
+        let inputError: Error | undefined;
+        // Stream decoding preserves multibyte filenames even when a character spans two output chunks.
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk: string) => stdoutChunks.push(chunk));
+        child.stderr.on('data', (chunk: string) => stderrChunks.push(chunk));
+        child.on('error', (error) => {
+            processError = error;
+        });
+        child.stdin.on('error', (error) => {
+            // A failed Git command may close stdin early. Keep its exit status and stderr as the primary error.
+            inputError = error;
+        });
+        child.on('close', (code, signal) => {
+            const stdout = stdoutChunks.join('');
+            const stderr = stderrChunks.join('');
+            if (processError) {
+                reject(Object.assign(processError, { stdout, stderr }));
+            } else if (code !== 0 || signal) {
+                reject(
+                    Object.assign(new Error(`Command failed: git ${argumentsList.join(' ')}\n${stderr}`), {
+                        code,
+                        signal,
+                        killed: child.killed,
+                        stdout,
+                        stderr,
+                    }),
+                );
+            } else if (inputError) {
+                reject(Object.assign(inputError, { stdout, stderr }));
+            } else {
+                resolve(stdout);
+            }
+        });
+        // Index-info uses NUL-delimited input. Closing stdin also lets commands finish when input is empty.
+        child.stdin.end(options?.input);
     });
-    return result.stdout;
 }
 
 /** Translates discovery failures without ever treating an ownership or executable error as permission to init. */