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

package/bin/submodules.js

@@ -18,7 +18,7 @@ function payloadString(payload, key) {
     return String(payload[key] ?? '').trim();
 }
 /** Builds one modal row for a submodule entry. */
-function buildSubmoduleRow(entry) {
+export function buildSubmoduleRow(entry) {
     const metaBits = [entry.commit ? `commit ${entry.commit}` : '', entry.branch ? `branch ${entry.branch}` : '']
         .map((part) => String(part || '').trim())
         .filter(Boolean);
@@ -34,6 +34,12 @@ function buildSubmoduleRow(entry) {
         description,
         actions: [
             { type: 'button', id: 'submodules-update', content: 'Update', payload: { path: entry.path } },
+            {
+                type: 'button',
+                id: 'submodules-update-remote',
+                content: 'Update Remote',
+                payload: { path: entry.path },
+            },
             { type: 'button', id: 'submodules-sync', content: 'Sync', payload: { path: entry.path } },
             {
                 type: 'button',
@@ -45,47 +51,96 @@ function buildSubmoduleRow(entry) {
         ],
     };
 }
+/** Builds an error fallback modal with a descriptive message. */
+function buildErrorModal(message) {
+    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, error, openFallback = (message) => buildErrorModal(message).open()) {
+    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() {
     const git = createGitCommand();
-    const entries = git.listSubmodules();
+    let entries;
+    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) {
+    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',
+            id: 'url',
+            label: 'Submodule URL',
+            kind: 'url',
+            placeholder: 'https://example.com/repo.git',
+        },
+        {
+            type: 'grid',
+            columns: 'minmax(0, 1fr) minmax(0, 1fr)',
+            gap: '.75rem',
+            content: [
+                {
+                    type: 'input',
+                    id: 'path',
+                    label: 'Submodule Path',
+                    placeholder: 'libs/example',
+                },
+                {
+                    type: 'input',
+                    id: 'name',
+                    label: 'Submodule Name',
+                    placeholder: 'example',
+                },
+            ],
+        },
+        {
+            type: 'input',
+            id: 'branch',
+            label: 'Branch (optional)',
+            placeholder: 'main',
+        },
+    ], { gap: '1rem' })
+        .horizontalBox([
+        { type: 'button', id: 'submodules-add', content: 'Add Submodule', variant: 'primary' },
+        { type: 'button', id: 'repo-submodules', content: 'Refresh' },
+    ], { gap: '.5rem', align: 'centered', wrap: true })
+        .horizontalBox([
+        { type: 'button', id: 'submodules-update-all', content: 'Update All (Recursive)' },
+        { type: 'button', id: 'submodules-update-all-remote', content: 'Update All From Branches' },
+        { type: 'button', 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, name) {
@@ -95,15 +150,22 @@ async function openRemoveConfirmationModal(path, name) {
     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', id: 'repo-submodules', content: 'Back' },
+        {
+            type: 'button',
+            id: 'submodules-remove-confirm',
+            content: 'Remove Submodule',
+            variant: 'danger',
+            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. */
 async function removeSubmodule(payload) {
@@ -136,6 +198,15 @@ async function updateSubmodule(payload) {
     git.updateSubmodule(path);
     await openSubmodulesModal();
 }
+/** Updates one submodule from its configured branch and refreshes the toolkit modal. */
+async function updateSubmoduleRemote(payload) {
+    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) {
     const path = payloadString(payload, 'path');
@@ -151,6 +222,12 @@ async function updateAllSubmodules() {
     git.updateAllSubmodules();
     await openSubmodulesModal();
 }
+/** Updates all submodules from their configured branches and refreshes the toolkit modal. */
+async function updateAllSubmodulesRemote() {
+    const git = createGitCommand();
+    git.updateAllSubmodulesRemote();
+    await openSubmodulesModal();
+}
 /** Syncs all submodules recursively and refreshes the toolkit modal. */
 async function syncAllSubmodules() {
     const git = createGitCommand();
@@ -159,7 +236,7 @@ async function syncAllSubmodules() {
 }
 /** Registers the Git submodule toolkit menu and action handlers. */
 export function registerSubmoduleToolkit() {
-    const repoMenu = getOrCreateMenu('repository', 'Repository');
+    const repoMenu = getOrCreateMenu('repository', 'Repository', { surface: 'menubar' });
     repoMenu?.addItem({ label: 'Submodules', action: 'repo-submodules' });
     registerAction('repo-submodules', async () => {
         console.log('Git submodules: repo-submodules action invoked');
@@ -171,12 +248,18 @@ export function registerSubmoduleToolkit() {
     registerAction('submodules-update-all', async () => {
         return updateAllSubmodules();
     });
+    registerAction('submodules-update-all-remote', async () => {
+        return updateAllSubmodulesRemote();
+    });
     registerAction('submodules-sync-all', async () => {
         return syncAllSubmodules();
     });
     registerAction('submodules-update', async (payload) => {
         return updateSubmodule(asPayload(payload));
     });
+    registerAction('submodules-update-remote', async (payload) => {
+        return updateSubmoduleRemote(asPayload(payload));
+    });
     registerAction('submodules-sync', async (payload) => {
         return syncSubmodule(asPayload(payload));
     });

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "@openvcs/git-plugin",
-  "version": "0.1.0",
+  "version": "0.2.0-edge.20260426.39",
   "description": "OpenVCS Git plugin - Node.js runtime",
   "license": "GPL-3.0-or-later",
+  "homepage": "https://github.com/Open-VCS/OpenVCS-Plugin-Git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Open-VCS/OpenVCS-Plugin-Git.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Open-VCS/OpenVCS-Plugin-Git/issues"
+  },
   "type": "module",
   "engines": {
     "node": ">=18"
@@ -10,7 +18,7 @@
   "openvcs": {
     "id": "openvcs.git",
     "name": "Git",
-    "version": "0.1.0",
+    "version": "0.2.0-edge.20260426.39",
     "author": "OpenVCS Contributors",
     "description": "Git VCS backend plugin for OpenVCS",
     "default_enabled": true,
@@ -29,7 +37,7 @@
     "build": "node ./node_modules/@openvcs/sdk/bin/openvcs.js build"
   },
   "dependencies": {
-    "@openvcs/sdk": "^0.2.16"
+    "@openvcs/sdk": "edge"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",

package/src/git.ts

@@ -14,10 +14,12 @@ import type {
 } from '@openvcs/sdk/types';
 import type { GitCommandResult, RunGitOptions } from './plugin-types.js';
 import {
+  applySubmoduleStatusHints,
   asString,
   buildFetchArgs,
   buildPullFfOnlyArgs,
   buildPushArgs,
+  buildSubmoduleUpdateArgs,
   parseCommits,
   parseStatusOutput,
 } from './plugin-helpers.js';
@@ -148,7 +150,7 @@ export class GitCommand {
 
   status(): StatusParseResult & { exitCode: number } {
     const result = this.run(['status', '--porcelain=1', '--branch', '-z', '-uall']);
-    const parsed = parseStatusOutput(result.stdout);
+    const parsed = applySubmoduleStatusHints(parseStatusOutput(result.stdout), this.listSubmodulePaths());
     return { ...parsed, exitCode: result.status };
   }
 
@@ -272,31 +274,49 @@ export class GitCommand {
     return this.runChecked(args, 'git-pull-failed');
   }
 
-  commit(message: string): GitCommandResult {
-    return this.runChecked(['commit', '-m', message], 'git-commit-failed');
+  /** Returns the current HEAD commit id. */
+  currentHead(): string {
+    return this.runChecked(['rev-parse', 'HEAD'], 'git-head-failed').stdout.trim();
   }
 
-  commitIndex(message?: string, name?: string, email?: string, paths?: string[]): GitCommandResult {
-    const args = ['commit'];
-    
-    if (paths && paths.length > 0) {
-      args.push('--', ...paths);
-    } else {
-      args.push('-a');
-    }
-    
+  /** Creates a commit, optionally limited to the provided paths. */
+  commit(message: string, name?: string, email?: string, paths?: string[]): GitCommandResult {
+    const execArgs = [
+      ...(name ? ['-c', `user.name=${name}`] : []),
+      ...(email ? ['-c', `user.email=${email}`] : []),
+      'commit',
+      '-m',
+      message,
+      ...(paths && paths.length > 0 ? ['--', ...paths] : []),
+    ];
+
+    return this.runChecked(execArgs, 'git-commit-failed');
+  }
+
+  /** Creates a commit from the current index only. */
+  commitIndex(message?: string, name?: string, email?: string): GitCommandResult {
     const commitMessage = message || 'Stage changes';
-    
+
     const execArgs = [
       ...(name ? ['-c', `user.name=${name}`] : []),
       ...(email ? ['-c', `user.email=${email}`] : []),
-      ...args,
-      '-m', commitMessage,
+      'commit',
+      '-m',
+      commitMessage,
     ];
-    
+
     return this.runChecked(execArgs, 'git-commit-failed');
   }
 
+  /** Stages the provided repository-relative paths into the index. */
+  stagePaths(paths: string[]): void {
+    if (paths.length === 0) {
+      return;
+    }
+
+    this.runChecked(['add', '-A', '--', ...paths], 'git-stage-paths-failed');
+  }
+
   listCommits(options: ListCommitsOptions = {}): { commits: CommitEntry[]; exitCode: number } {
     const args = ['log', '--all'];
 
@@ -328,7 +348,7 @@ export class GitCommand {
       args.push(`--until=${options.until_utc}`);
     }
 
-    args.push('--pretty=format:%H%f%x00%aN%x00%aI%x00%P%x1e');
+    args.push('--pretty=format:%H%x00%s%x00%aN%x00%aI%x00%P%x1e');
 
     if (options.branch) {
       args.push(options.branch);
@@ -343,9 +363,13 @@ export class GitCommand {
     return { commits, exitCode: result.status };
   }
 
-  listSubmodules(): SubmoduleEntry[] {
+  /** Reads `.gitmodules` entries indexed by submodule name and path. */
+  private readSubmoduleConfig(): {
+    byName: Map<string, { name: string; path?: string; url?: string; branch?: string }>;
+    byPath: Map<string, { name: string; url?: string; branch?: string }>;
+  } {
     const configResult = this.run(['config', '-f', '.gitmodules', '--null', '--list']);
-    const configByName = new Map<string, { name: string; path?: string; url?: string; branch?: string }>();
+    const byName = new Map<string, { name: string; path?: string; url?: string; branch?: string }>();
 
     if (configResult.status === 0) {
       for (const entry of configResult.stdout.split('\0')) {
@@ -361,23 +385,34 @@ export class GitCommand {
         if (!match) continue;
 
         const [, name, field] = match;
-        const target = configByName.get(name) || { name };
+        const target = byName.get(name) || { name };
 
         if (field === 'path') target.path = value;
         if (field === 'url') target.url = value;
         if (field === 'branch') target.branch = value;
 
-        configByName.set(name, target);
+        byName.set(name, target);
       }
     }
 
-    const configByPath = new Map<string, { name: string; url?: string; branch?: string }>();
-    for (const entry of configByName.values()) {
+    const byPath = new Map<string, { name: string; url?: string; branch?: string }>();
+    for (const entry of byName.values()) {
       if (entry.path) {
-        configByPath.set(entry.path, entry);
+        byPath.set(entry.path, entry);
       }
     }
 
+    return { byName, byPath };
+  }
+
+  /** Returns known submodule paths from `.gitmodules`. */
+  private listSubmodulePaths(): Set<string> {
+    return new Set(this.readSubmoduleConfig().byPath.keys());
+  }
+
+  listSubmodules(): SubmoduleEntry[] {
+    const { byPath: configByPath } = this.readSubmoduleConfig();
+
     const statusResult = this.run(['submodule', 'status', '--recursive']);
     if (statusResult.status !== 0) {
       return [];
@@ -423,11 +458,21 @@ export class GitCommand {
   }
 
   updateSubmodule(path: string): GitCommandResult {
-    return this.runChecked(['submodule', 'update', '--init', '--recursive', '--', path], 'git-submodule-update-failed');
+    return this.runChecked(buildSubmoduleUpdateArgs({ path }), 'git-submodule-update-failed');
   }
 
   updateAllSubmodules(): GitCommandResult {
-    return this.runChecked(['submodule', 'update', '--init', '--recursive'], 'git-submodule-update-failed');
+    return this.runChecked(buildSubmoduleUpdateArgs({}), 'git-submodule-update-failed');
+  }
+
+  /** Updates one submodule from its configured branch recursively. */
+  updateSubmoduleRemote(path: string): GitCommandResult {
+    return this.runChecked(buildSubmoduleUpdateArgs({ path, remote: true }), 'git-submodule-update-remote-failed');
+  }
+
+  /** Updates all submodules from their configured branches recursively. */
+  updateAllSubmodulesRemote(): GitCommandResult {
+    return this.runChecked(buildSubmoduleUpdateArgs({ remote: true }), 'git-submodule-update-remote-failed');
   }
 
   syncSubmodule(path: string): GitCommandResult {
@@ -498,8 +543,11 @@ export class GitCommand {
     return this.run(['hash-object', '-w', '--stdin'], { stdin: content }).stdout.trim();
   }
 
+  /** Stages a textual patch into the index without requiring worktree/index parity. */
   stagePatch(patch: string): void {
-    this.runChecked(['apply', '--3way', '--index'], 'git-stage-patch-failed', { stdin: patch });
+    this.runChecked(['apply', '--cached', '--unidiff-zero'], 'git-stage-patch-failed', {
+      stdin: patch,
+    });
   }
 
   applyReversePatch(patch: string): void {
@@ -514,9 +562,10 @@ export class GitCommand {
     this.runChecked(['reset', '--soft', ref], 'git-reset-soft-failed');
   }
 
+  /** Reads the effective Git commit identity from config. */
   getIdentity(): { name: string; email: string } | null {
-    const nameResult = this.run(['config', '--local', 'user.name']);
-    const emailResult = this.run(['config', '--local', 'user.email']);
+    const nameResult = this.run(['config', '--get', 'user.name']);
+    const emailResult = this.run(['config', '--get', 'user.email']);
 
     if (nameResult.status !== 0 || emailResult.status !== 0) {
       return null;
@@ -528,6 +577,7 @@ export class GitCommand {
     };
   }
 
+  /** Stores repository-local commit identity in Git config. */
   setIdentityLocal(name: string, email: string): void {
     this.runChecked(['config', '--local', 'user.name', name], 'git-identity-set-failed');
     this.runChecked(['config', '--local', 'user.email', email], 'git-identity-set-failed');

package/src/plugin-helpers.ts

@@ -74,6 +74,14 @@ export function buildPushArgs(params: RequestParams): string[] {
   return args;
 }
 
+/** Builds `git clone` arguments with recursive submodule initialization enabled. */
+export function buildCloneArgs(params: RequestParams): string[] {
+  const args = ['clone', '--recurse-submodules'];
+  pushOptionalArg(args, params.url);
+  pushOptionalArg(args, params.dest);
+  return args;
+}
+
 /** Builds `git pull --ff-only` arguments while omitting empty optional values. */
 export function buildPullFfOnlyArgs(params: RequestParams): string[] {
   const args = ['pull', '--ff-only'];
@@ -82,6 +90,22 @@ export function buildPullFfOnlyArgs(params: RequestParams): string[] {
   return args;
 }
 
+/** Builds `git submodule update` arguments for pinned or remote-tracking updates. */
+export function buildSubmoduleUpdateArgs(params: RequestParams): string[] {
+  const args = ['submodule', 'update', '--init', '--recursive'];
+
+  if (params.remote === true) {
+    args.push('--remote');
+  }
+
+  const path = asTrimmedString(params.path);
+  if (path) {
+    args.push('--', path);
+  }
+
+  return args;
+}
+
 /** Parses `git status --porcelain=1 --branch -z -uall` output into OpenVCS payloads. */
 export function parseStatusOutput(output: string): StatusParseResult {
   const records = output.split('\0').filter(Boolean);
@@ -164,6 +188,40 @@ export function parseStatusOutput(output: string): StatusParseResult {
   };
 }
 
+/** Applies submodule-specific status labels to known submodule paths. */
+export function applySubmoduleStatusHints(
+  parsed: StatusParseResult,
+  submodulePaths: Iterable<string>,
+): StatusParseResult {
+  const knownPaths = new Set(
+    Array.from(submodulePaths)
+      .map((entry) => asTrimmedString(entry))
+      .filter(Boolean),
+  );
+
+  if (knownPaths.size === 0) {
+    return parsed;
+  }
+
+  return {
+    ...parsed,
+    payload: {
+      ...parsed.payload,
+      files: parsed.payload.files.map((file) => {
+        const path = asTrimmedString(file.path);
+        if (!knownPaths.has(path)) {
+          return file;
+        }
+
+        return {
+          ...file,
+          status: 'S',
+        };
+      }),
+    },
+  };
+}
+
 /** Parses `git log` output into commit entries expected by the host. */
 export function parseCommits(raw: string): CommitEntry[] {
   const records = raw