@maudecode/talaria-web 1.15.0 → 1.17.2

package/dist/workspace/git.d.ts

@@ -6,6 +6,8 @@ export declare const STATUS_CACHE_LIMIT = 32;
 export declare const DIFF_SIZE_LIMIT: number;
 export declare const COMMIT_MESSAGE_DIFF_LIMIT: number;
 export declare const WORKSPACE_GIT_DESTRUCTIVE_ENV = "HERMES_WEBUI_WORKSPACE_GIT_DESTRUCTIVE";
+export declare const WORKSPACE_BUSY_MESSAGE = "A Git operation is running in this workspace.";
+export declare const WORKSPACE_WRITE_BUSY_MESSAGE = "A file operation is running in this workspace.";
 export declare class GitWorkspaceError extends Error {
     readonly code: string;
     constructor(message: string, code?: string);
@@ -86,6 +88,10 @@ export interface GitRunnerDeps {
     env: Record<string, string | undefined>;
     /** Generates commit messages from a prompt (sidecar `aux.complete`). */
     now?: () => number;
+    /** How long a mutation waits for the repo's previous one before answering `operation_in_progress`. */
+    mutationLockTimeoutMs?: number;
+    /** Whether a chat run is active in a workspace overlapping `path`; a working-tree mutation refuses to start then. */
+    activeRunIn?: (path: string) => boolean;
 }
 interface RunOptions {
     timeoutMs?: number;
@@ -96,37 +102,78 @@ interface RunOptions {
     disableFilterAttributes?: boolean;
     neutralizeFilterPrograms?: boolean;
     neutralizeRemoteHelpers?: boolean;
-    input?: string;
 }
 export interface GitResult {
     status: number;
     stdout: string;
     stderr: string;
 }
+export interface GitSpawn {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: NodeJS.ErrnoException;
+}
+/**
+ * Run `git` without blocking the event loop, resolving like `spawnSync`: the exit status (null when a signal ended it),
+ * plus the `error` that prevented a normal run (`ETIMEDOUT` when the timeout killed it). Without `env` the child
+ * inherits the server's environment.
+ */
+export declare function spawnGit(cwd: string, argv: string[], timeoutMs: number, env?: Record<string, string>): Promise<GitSpawn>;
+/**
+ * The nearest directory at or above `path` holding a `.git` entry (a repository, linked worktree, or submodule root), the
+ * root Git itself would discover, found synchronously so a caller can hold it before its first await.
+ */
+export declare function enclosingRepoRoot(path: string): string | null;
+/** Whether two paths are the same directory or one contains the other. */
+export declare function pathsOverlap(a: string, b: string): boolean;
 export declare function classifyGitError(message: string, args?: string[]): string;
 export declare class GitRunner {
     readonly deps: GitRunnerDeps;
     private readonly locks;
     private readonly statusCache;
     private readonly generations;
+    /** Workspaces a working-tree mutation or worktree removal is changing; runs, terminals, and file writes stay out. */
+    private readonly busy;
+    /** Workspaces an asynchronous writer (worktree creation) is changing; working-tree mutations stay out. */
+    private readonly writing;
     constructor(deps: GitRunnerDeps);
+    /**
+     * Hold `path` busy until `fn` settles. The hold is taken before `fn` runs, so checks `fn` makes synchronously (no run
+     * active) and admission's `workspaceBusy` refusal leave no gap for a chat run, terminal, or file write in between.
+     */
+    holdWorkspace<T>(path: string, fn: () => Promise<T>): Promise<T>;
+    /** Whether `path` overlaps a held workspace (the same directory, inside it, or containing it). */
+    workspaceBusy(path: string): boolean;
+    /** Run an asynchronous workspace writer at `path`: refused while Git holds it, and Git mutations refuse meanwhile. */
+    holdWrite<T>(path: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Worktree removal: serialized with Git mutations in the main checkout and in the worktree (the same per-repo locks),
+     * and held busy so no run, terminal, or file write starts there. `fn`'s synchronous lock checks run inside the hold.
+     */
+    removeWorktreeExclusive<T>(worktree: string, repoRoot: string | null, fn: () => Promise<T>): Promise<T>;
     destructiveEnabled(): boolean;
     private cleanEnv;
     private now;
-    private rawGit;
     private configNamesForScope;
     private namesLocalAndWorktree;
     private filterNames;
     private mergeDriverNames;
     private remoteHelperNames;
     private static legal;
-    hasRepoLocalFilters(cwd: string): boolean;
-    run(ctxOrCwd: GitContext | string, args: string[], opts?: RunOptions): GitResult;
-    resolveContext(workspace: string): GitContext | null;
+    hasRepoLocalFilters(cwd: string): Promise<boolean>;
+    run(ctxOrCwd: GitContext | string, args: string[], opts?: RunOptions): Promise<GitResult>;
+    resolveContext(workspace: string): Promise<GitContext | null>;
     private static workspacePathspec;
     private static repoRel;
     private static workspaceRel;
+    /**
+     * The per-repo mutation lock. `holdRepo` (working-tree mutations) also holds the whole repository busy and, in the same
+     * tick, refuses when a run or an asynchronous writer is already active anywhere in it.
+     */
     private withMutationLock;
+    private assertRepoFree;
+    private withLock;
     private static resolveGitDir;
     private statusFingerprint;
     private cachedStatus;
@@ -140,10 +187,10 @@ export declare class GitRunner {
     private static countUntrackedFile;
     status(workspace: string, opts?: {
         useCache?: boolean;
-    }): GitStatus;
+    }): Promise<GitStatus>;
     private branchAheadBehind;
     private forEachRef;
-    branches(workspace: string): GitBranches;
+    branches(workspace: string): Promise<GitBranches>;
     private validateLocalBranch;
     private validateRemoteBranch;
     private validateCheckoutStart;
@@ -166,7 +213,7 @@ export declare class GitRunner {
         track?: boolean;
     }): Promise<Record<string, unknown>>;
     private static syntheticUntrackedDiff;
-    diff(workspace: string, path: string, kind?: string): GitDiff;
+    diff(workspace: string, path: string, kind?: string): Promise<GitDiff>;
     private static cleanPaths;
     private static pathspecs;
     private blockFilteredDestructiveWrite;
@@ -182,8 +229,8 @@ export declare class GitRunner {
     private selectedFiles;
     private selectedDiffText;
     private static fileLines;
-    selectedCommitMessagePrompt(workspace: string, paths: Iterable<unknown>): CommitMessagePrompt;
-    stagedCommitMessagePrompt(workspace: string): CommitMessagePrompt;
+    selectedCommitMessagePrompt(workspace: string, paths: Iterable<unknown>): Promise<CommitMessagePrompt>;
+    stagedCommitMessagePrompt(workspace: string): Promise<CommitMessagePrompt>;
     commit(workspace: string, message: string): Promise<Record<string, unknown>>;
     commitSelected(workspace: string, message: string, paths: Iterable<unknown>): Promise<Record<string, unknown>>;
     private branchName;