@openvcs/git-plugin 0.1.0 → 0.2.0-edge.20260426.39

package/src/plugin-request-handler.ts

@@ -14,10 +14,93 @@ import {
   asString,
   asStringArray,
   asTrimmedString,
+  buildCloneArgs,
+  parseStatusOutput,
 } from './plugin-helpers.js';
 import { GitCommand } from './git.js';
 import type { GitSession } from './plugin-types.js';
 
+/** Describes the Git operations needed to discard a set of paths safely. */
+export interface DiscardPathPlan {
+  /** Restores tracked paths from HEAD in both the index and worktree. */
+  restore: string[];
+  /** Removes newly added index entries before deleting their worktree files. */
+  unstageThenRemove: string[];
+  /** Deletes untracked worktree paths after index state has been corrected. */
+  clean: string[];
+}
+
+/** Returns an optional boolean only when the input is already a boolean. */
+function asOptionalBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+/** Reduces a file status string to the primary status code needed for discard routing. */
+function getPrimaryDiscardStatus(status: string): string {
+  const normalized = asTrimmedString(status);
+  if (!normalized) {
+    return 'M';
+  }
+
+  for (const candidate of ['?', 'R', 'C', 'A', 'D', 'U', 'T', 'S', 'M']) {
+    if (normalized.includes(candidate)) {
+      return candidate;
+    }
+  }
+
+  return normalized[0] ?? 'M';
+}
+
+/** Builds a discard plan that handles tracked, added, copied, and renamed paths. */
+export function planDiscardPaths(statusOutput: string): DiscardPathPlan {
+  const restore = new Set<string>();
+  const unstageThenRemove = new Set<string>();
+  const clean = new Set<string>();
+  const parsed = parseStatusOutput(statusOutput);
+
+  for (const file of parsed.payload.files) {
+    const path = asTrimmedString(file.path);
+    const oldPath = asTrimmedString(file.old_path);
+    const primaryStatus = getPrimaryDiscardStatus(file.status);
+
+    if (!path) {
+      continue;
+    }
+
+    if (primaryStatus === '?') {
+      clean.add(path);
+      continue;
+    }
+
+    if (primaryStatus === 'R') {
+      if (oldPath) {
+        restore.add(oldPath);
+      }
+      if (file.staged) {
+        unstageThenRemove.add(path);
+      }
+      clean.add(path);
+      continue;
+    }
+
+    if (primaryStatus === 'C' || primaryStatus === 'A') {
+      if (file.staged) {
+        unstageThenRemove.add(path);
+      }
+      clean.add(path);
+      continue;
+    }
+
+    restore.add(path);
+  }
+
+  return {
+    restore: Array.from(restore),
+    unstageThenRemove: Array.from(unstageThenRemove),
+    clean: Array.from(clean),
+  };
+}
+
 /** Describes the Git runtime services consumed by the VCS delegates. */
 export interface GitRuntimeDependencies {
   /** Allocates a new repository session and returns its id. */
@@ -92,7 +175,7 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     }
 
     const git = this.deps.createGitCommand(process.cwd());
-    const output = git.runChecked(['clone', url, destination], 'vcs-clone-failed');
+    const output = git.runChecked(buildCloneArgs({ url, dest: destination }), 'vcs-clone-failed');
     const lines = `${output.stdout}\n${output.stderr}`
       .split(/\r?\n/g)
       .map((line) => line.trim())
@@ -270,9 +353,13 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     _context: PluginRuntimeContext,
   ): string {
     const git = this.requireGit(params.session_id);
-    const result = git.runChecked(['rev-parse', 'HEAD'], 'git-commit-failed');
-    git.commit(asTrimmedString(params.message));
-    return result.stdout.trim();
+    git.commit(
+      asTrimmedString(params.message),
+      asTrimmedString(params.name),
+      asTrimmedString(params.email),
+      asStringArray(params.paths),
+    );
+    return git.currentHead();
   }
 
   override commitIndex(
@@ -280,14 +367,12 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     _context: PluginRuntimeContext,
   ): string {
     const git = this.requireGit(params.session_id);
-    const result = git.runChecked(['rev-parse', 'HEAD'], 'git-commit-failed');
     git.commitIndex(
       asTrimmedString(params.message),
       asTrimmedString(params.name),
       asTrimmedString(params.email),
-      asStringArray(params.paths),
     );
-    return result.stdout.trim();
+    return git.currentHead();
   }
 
   override getStatusSummary(
@@ -316,8 +401,8 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
       branch: asTrimmedString(query.rev) || undefined,
       skip: asNumber(query.skip, 0) || undefined,
       limit: asNumber(query.limit, 0),
-      topo_order: query.topo_order as boolean ?? undefined,
-      include_merges: query.include_merges as boolean ?? undefined,
+      topo_order: asOptionalBoolean(query.topo_order),
+      include_merges: asOptionalBoolean(query.include_merges),
       author_contains: asTrimmedString(query.author_contains) || undefined,
       since_utc: asTrimmedString(query.since_utc) || undefined,
       until_utc: asTrimmedString(query.until_utc) || undefined,
@@ -385,6 +470,15 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
     return null;
   }
 
+  override stagePaths(
+    params: OpenVcs.VcsStagePathsParams,
+    _context: PluginRuntimeContext,
+  ): null {
+    const git = this.requireGit(params.session_id);
+    git.stagePaths(asStringArray(params.paths));
+    return null;
+  }
+
   override discardPaths(
     params: OpenVcs.VcsDiscardPathsParams,
     _context: PluginRuntimeContext,
@@ -395,7 +489,44 @@ export class GitVcsDelegates extends VcsDelegateBase<GitRuntimeDependencies> {
       return null;
     }
 
-    git.runChecked(['checkout', '--', ...paths], 'git-discard-paths-failed');
+    const status = git.runChecked(
+      ['status', '--porcelain=1', '-z', '-uall', '--', ...paths],
+      'git-discard-paths-failed',
+    );
+    const discardPlan = planDiscardPaths(status.stdout);
+
+    let failure: unknown;
+
+    if (discardPlan.unstageThenRemove.length > 0) {
+      try {
+        git.runChecked(
+          ['rm', '-f', '--cached', '--', ...discardPlan.unstageThenRemove],
+          'git-discard-paths-failed',
+        );
+      } catch (error) {
+        failure = error;
+      }
+    }
+
+    if (!failure && discardPlan.restore.length > 0) {
+      try {
+        git.runChecked(
+          ['restore', '--source=HEAD', '--staged', '--worktree', '--', ...discardPlan.restore],
+          'git-discard-paths-failed',
+        );
+      } catch (error) {
+        failure = error;
+      }
+    }
+
+    if (!failure && discardPlan.clean.length > 0) {
+      git.runChecked(['clean', '-f', '--', ...discardPlan.clean], 'git-discard-paths-failed');
+    }
+
+    if (failure) {
+      throw failure;
+    }
+
     return null;
   }
 

package/src/plugin.ts

@@ -58,7 +58,7 @@ export function OnPluginStart(): void {
   const delegates = new GitVcsDelegates(createGitRuntimeDependencies());
   PluginDefinition.vcs = delegates.toDelegates();
 
-  const repoMenu = getOrCreateMenu('repository', 'Repository');
+  const repoMenu = getOrCreateMenu('repository', 'Repository', { surface: 'menubar' });
   if (repoMenu) {
     repoMenu.addItem({ label: 'Edit .gitignore', action: 'repo-edit-gitignore' });
     repoMenu.addItem({ label: 'Edit .gitattributes', action: 'repo-edit-gitattributes' });

package/src/submodules.ts

@@ -26,7 +26,7 @@ function payloadString(payload: ModalActionPayload, key: string): string {
 }
 
 /** Builds one modal row for a submodule entry. */
-function buildSubmoduleRow(entry: SubmoduleEntry) {
+export function buildSubmoduleRow(entry: SubmoduleEntry) {
   const metaBits = [entry.commit ? `commit ${entry.commit}` : '', entry.branch ? `branch ${entry.branch}` : '']
     .map((part) => String(part || '').trim())
     .filter(Boolean);
@@ -44,6 +44,12 @@ function buildSubmoduleRow(entry: SubmoduleEntry) {
     description,
     actions: [
       { type: 'button' as const, id: 'submodules-update', content: 'Update', payload: { path: entry.path } },
+      {
+        type: 'button' as const,
+        id: 'submodules-update-remote',
+        content: 'Update Remote',
+        payload: { path: entry.path },
+      },
       { type: 'button' as const, id: 'submodules-sync', content: 'Sync', payload: { path: entry.path } },
       {
         type: 'button' as const,
@@ -56,69 +62,143 @@ function buildSubmoduleRow(entry: SubmoduleEntry) {
   };
 }
 
+/** Builds an error fallback modal with a descriptive message. */
+function buildErrorModal(message: string): ModalBuilder {
+  return new ModalBuilder('Error').text(message).text('Please try again or check the Git repository state.');
+}
+
+/** Opens a fallback modal for a submodule UI failure and preserves the original error on fallback failure. */
+export async function handleSubmoduleModalError(
+  prefix: string,
+  error: unknown,
+  openFallback: (message: string) => Promise<unknown> = (message) => buildErrorModal(message).open(),
+): Promise<unknown> {
+  const message = error instanceof Error ? error.message : String(error);
+  const fullMessage = `${prefix}: ${message}`;
+  console.error(`Git submodules: ${fullMessage}`);
+
+  try {
+    return await openFallback(fullMessage);
+  } catch {
+    throw error;
+  }
+}
+
 /** Builds and opens the submodule manager modal. */
 async function openSubmodulesModal(): Promise<unknown> {
   const git = createGitCommand();
-  const entries = git.listSubmodules();
+
+  let entries: SubmoduleEntry[];
+  try {
+    entries = git.listSubmodules();
+  } catch (error) {
+    return handleSubmoduleModalError('failed to list submodules', error);
+  }
+
   console.log('Git submodules: building modal', { count: entries.length });
 
-  const modal = new ModalBuilder('Manage Submodules')
+  const modal = buildSubmodulesModal(entries);
+  try {
+    return await modal.open();
+  } catch (error) {
+    return handleSubmoduleModalError('failed to open modal', error);
+  }
+}
+
+/** Builds the submodule manager modal with given entries. */
+function buildSubmodulesModal(entries: SubmoduleEntry[]): ModalBuilder {
+  return new ModalBuilder('Manage Submodules')
     .text('Review, add, update, sync, and remove submodules without leaving Git.')
+    .text('Use Update Remote to follow each submodule branch configured in .gitmodules.')
     .separator()
-    .input('url', 'Submodule URL', {
-      kind: 'url',
-      placeholder: 'https://example.com/repo.git',
-    })
-    .input('path', 'Submodule Path', {
-      placeholder: 'libs/example',
-    })
-    .input('name', 'Submodule Name', {
-      placeholder: 'example',
-    })
-    .input('branch', 'Branch (optional)', {
-      placeholder: 'main',
-    })
-    .button('submodules-add', 'Add Submodule', {
-      variant: 'primary',
-      align: 'centered',
-    })
-    .button('repo-submodules', 'Refresh', {
-      align: 'centered',
-    })
-    .button('submodules-update-all', 'Update All (Recursive)', {
-      align: 'centered',
-    })
-    .button('submodules-sync-all', 'Sync All', {
-      align: 'centered',
-    })
+    .verticalBox(
+      [
+        {
+          type: 'input' as const,
+          id: 'url',
+          label: 'Submodule URL',
+          kind: 'url' as const,
+          placeholder: 'https://example.com/repo.git',
+        },
+        {
+          type: 'grid' as const,
+          columns: 'minmax(0, 1fr) minmax(0, 1fr)',
+          gap: '.75rem',
+          content: [
+            {
+              type: 'input' as const,
+              id: 'path',
+              label: 'Submodule Path',
+              placeholder: 'libs/example',
+            },
+            {
+              type: 'input' as const,
+              id: 'name',
+              label: 'Submodule Name',
+              placeholder: 'example',
+            },
+          ],
+        },
+        {
+          type: 'input' as const,
+          id: 'branch',
+          label: 'Branch (optional)',
+          placeholder: 'main',
+        },
+      ],
+      { gap: '1rem' },
+    )
+    .horizontalBox(
+      [
+        { type: 'button' as const, id: 'submodules-add', content: 'Add Submodule', variant: 'primary' as const },
+        { type: 'button' as const, id: 'repo-submodules', content: 'Refresh' },
+      ],
+      { gap: '.5rem', align: 'centered', wrap: true },
+    )
+    .horizontalBox(
+      [
+        { type: 'button' as const, id: 'submodules-update-all', content: 'Update All (Recursive)' },
+        { type: 'button' as const, id: 'submodules-update-all-remote', content: 'Update All From Branches' },
+        { type: 'button' as const, id: 'submodules-sync-all', content: 'Sync All' },
+      ],
+      { gap: '.5rem', align: 'centered', wrap: true },
+    )
     .separator()
     .list('submodules', {
       label: 'Submodules',
       emptyText: 'This repository has no submodules yet.',
       items: entries.map((entry) => buildSubmoduleRow(entry)),
     });
-
-  return modal.open();
 }
 
 /** Builds and opens the remove confirmation modal for one submodule. */
 async function openRemoveConfirmationModal(path: string, name?: string): Promise<unknown> {
   const submodulePath = String(path || '').trim();
   if (!submodulePath) return;
+
   console.log('Git submodules: building remove confirmation', { path: submodulePath, name });
 
   const modal = new ModalBuilder('Confirm Submodule Removal')
     .text(`Remove the submodule at ${submodulePath}? This will deinitialize the submodule, remove it from the index, and delete its working tree entry.`)
-    .button('repo-submodules', 'Back', {
-      align: 'centered',
-    })
-    .button('submodules-remove-confirm', 'Remove Submodule', {
-      variant: 'danger',
-      align: 'centered',
-      payload: { path: submodulePath, name: String(name || '').trim() || undefined },
-    });
-
-  return modal.open();
+    .horizontalBox(
+      [
+        { type: 'button' as const, id: 'repo-submodules', content: 'Back' },
+        {
+          type: 'button' as const,
+          id: 'submodules-remove-confirm',
+          content: 'Remove Submodule',
+          variant: 'danger' as const,
+          payload: { path: submodulePath, name: String(name || '').trim() || undefined },
+        },
+      ],
+      { gap: '.5rem', align: 'centered', wrap: true },
+    );
+
+  try {
+    return await modal.open();
+  } catch (error) {
+    return handleSubmoduleModalError('failed to open remove confirmation modal', error);
+  }
 }
 
 /** Removes one submodule and refreshes the toolkit modal. */
@@ -155,6 +235,15 @@ async function updateSubmodule(payload: ModalActionPayload): Promise<void> {
   await openSubmodulesModal();
 }
 
+/** Updates one submodule from its configured branch and refreshes the toolkit modal. */
+async function updateSubmoduleRemote(payload: ModalActionPayload): Promise<void> {
+  const path = payloadString(payload, 'path');
+  if (!path) return;
+  const git = createGitCommand();
+  git.updateSubmoduleRemote(path);
+  await openSubmodulesModal();
+}
+
 /** Syncs one submodule and refreshes the toolkit modal. */
 async function syncSubmodule(payload: ModalActionPayload): Promise<void> {
   const path = payloadString(payload, 'path');
@@ -171,6 +260,13 @@ async function updateAllSubmodules(): Promise<void> {
   await openSubmodulesModal();
 }
 
+/** Updates all submodules from their configured branches and refreshes the toolkit modal. */
+async function updateAllSubmodulesRemote(): Promise<void> {
+  const git = createGitCommand();
+  git.updateAllSubmodulesRemote();
+  await openSubmodulesModal();
+}
+
 /** Syncs all submodules recursively and refreshes the toolkit modal. */
 async function syncAllSubmodules(): Promise<void> {
   const git = createGitCommand();
@@ -180,7 +276,7 @@ async function syncAllSubmodules(): Promise<void> {
 
 /** Registers the Git submodule toolkit menu and action handlers. */
 export function registerSubmoduleToolkit(): void {
-  const repoMenu = getOrCreateMenu('repository', 'Repository');
+  const repoMenu = getOrCreateMenu('repository', 'Repository', { surface: 'menubar' });
   repoMenu?.addItem({ label: 'Submodules', action: 'repo-submodules' });
 
   registerAction('repo-submodules', async () => {
@@ -196,6 +292,10 @@ export function registerSubmoduleToolkit(): void {
     return updateAllSubmodules();
   });
 
+  registerAction('submodules-update-all-remote', async () => {
+    return updateAllSubmodulesRemote();
+  });
+
   registerAction('submodules-sync-all', async () => {
     return syncAllSubmodules();
   });
@@ -204,6 +304,10 @@ export function registerSubmoduleToolkit(): void {
     return updateSubmodule(asPayload(payload));
   });
 
+  registerAction('submodules-update-remote', async (payload?: unknown) => {
+    return updateSubmoduleRemote(asPayload(payload));
+  });
+
   registerAction('submodules-sync', async (payload?: unknown) => {
     return syncSubmodule(asPayload(payload));
   });