dsh-ide-git 0.5.6 → 0.6.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-external/dsh-ide-git",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "main": "./src/index.js",
   "description": "IDE 级 Git 操作面板:分支树 + 提交图谱 + 变更/暂存/提交 + 提交详情。装了 dsh-better-sidebar 时挂成它的原生 tab(右侧栏 + 底部工作台);没装时直接挂 DSH 原生右侧栏,单独安装即可用。JetBrains 风格 Git 工具窗口 for DeepSeek Harness.",
   "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ide-git",
-  "version": "0.5.6",
+  "version": "0.6.0",
   "description": "DSH plugin: an IDE-grade Git tool window as a native dsh-better-sidebar tab — branch tree, commit graph, changes, commit details, JetBrains-style actions, in the right sidebar and the bottom panel. | DSH 插件:IDE 级 Git 工具窗口,以 dsh-better-sidebar 原生 Tab 挂载——分支树 / 提交图谱 / 变更与提交详情 / JetBrains 风格操作,右侧栏与底部面板双布局自适应。",
   "type": "module",
   "repository": {

package/src/index.js

@@ -1050,6 +1050,138 @@ async function compare(payload) {
 /** Directories never descended into while looking for repositories. */
 const REPO_SCAN_SKIP = new Set(['node_modules', 'dist', 'build', 'out', 'target', 'vendor', 'venv', '.venv', '__pycache__', 'coverage', 'tmp', 'temp'])
 
+/* The submodule walk spawns one short `git submodule status` per level, so the
+   depth is capped the same way the directory scan caps its own, and every list
+   stays bounded so a pathological tree cannot flood the picker. */
+const SUBMODULE_MAX_DEPTH = 2
+const SUBMODULE_LIST_LIMIT = 400
+const REPO_LIST_LIMIT = 60
+
+/** Slash-normalized path, for comparing paths that came from different
+ *  producers (git prints forward slashes; `path.join` prints backslashes on
+ *  Windows). Case-insensitive on Windows so the same checkout reached two ways
+ *  collapses to one row. */
+function pathIdentity(value) {
+  const normalized = value.replace(/\\/g, '/').replace(/\/+$/, '')
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized
+}
+
+/** One repository row shipped to the client (`kind` drives the picker badge). */
+function repoRow(root, submodulePath, kind) {
+  return {
+    path: root.replace(/\\/g, '/'),
+    /** Full checkout name; a submodule carries its repo-relative path so two
+     *  same-named checkouts stay apart in a long list. */
+    name: submodulePath === undefined ? path.basename(root) : submodulePath,
+    label: submodulePath === undefined ? path.basename(root) : submodulePath.split('/').pop(),
+    branch: null,
+    kind,
+    ...(submodulePath === undefined ? {} : { submodulePath }),
+  }
+}
+
+/**
+ * Every checkout registered as a submodule under `root`, at any depth.
+ *
+ * Git itself is the source of truth: `git submodule status --recursive` lists
+ * the registered paths (relative to the parent repository) even for submodules
+ * that were never initialised, and nested ones are reached by recursing into
+ * each listed path. A path that is present on disk and passes
+ * `rev-parse --show-toplevel` is a real, independent working tree — the parent
+ * only ever sees it as one gitlink line, so this is what makes it selectable
+ * as a repository of its own (the SourceTree behavior).
+ *
+ * The per-level `submodule status` calls are serial (a level's paths are only
+ * known once its parent answered), but the working-tree checks are not: they
+ * all run at once, because a repository with a dozen submodules otherwise
+ * costs a dozen sequential processes on every scan.
+ */
+async function collectSubmoduleRepos(root, depth = 1, prefix = '') {
+  const found = []
+  const listing = await runGit(root, ['submodule', 'status', '--recursive'])
+  if (listing.code !== 0) return found
+  const candidates = []
+  for (const raw of listing.stdout.split('\n')) {
+    if (candidates.length >= SUBMODULE_LIST_LIMIT) break
+    const line = raw.replace(/\r$/, '')
+    if (line.trim() === '') continue
+    /* `<state><sha> <path> (<describe>)`: the state prefix is ' ', '+', '-' or 'U'. */
+    const match = /^[\s+\-U]([0-9a-f]{4,64})\s+(.+?)(?:\s+\(.*\))?$/.exec(line)
+    const rel = (match === null ? line.trim().replace(/^[\s+\-U]\S*\s+/, '') : match[2]).trim().replace(/\\/g, '/')
+    if (rel === '') continue
+    const absolute = path.resolve(root, rel)
+    /* An uninitialised submodule has no `.git` yet: git still registers it, but
+       there is no working tree to bind the panel to. */
+    if (!existsSync(path.join(absolute, '.git'))) continue
+    candidates.push({ absolute, rel: `${prefix}${rel}` })
+  }
+  const tops = await Promise.all(candidates.map((entry) => runGit(entry.absolute, ['rev-parse', '--show-toplevel'])))
+  const next = []
+  for (let index = 0; index < candidates.length; index += 1) {
+    const top = tops[index]
+    if (top.code !== 0) continue
+    const reported = top.stdout.trim().replace(/\\/g, '/').replace(/\/+$/, '')
+    found.push({ root: reported === '' ? candidates[index].absolute : reported, rel: candidates[index].rel })
+    if (depth < SUBMODULE_MAX_DEPTH) next.push(candidates[index])
+  }
+  if (depth < SUBMODULE_MAX_DEPTH) {
+    const deeper = await Promise.all(next.map((entry) => collectSubmoduleRepos(entry.absolute, depth + 1, `${entry.rel}/`)))
+    for (const list of deeper) {
+      for (const entry of list) {
+        if (found.length >= SUBMODULE_LIST_LIMIT) break
+        found.push({ root: entry.root, rel: entry.rel })
+      }
+    }
+  }
+  return found
+}
+
+/** The whole discovery pass, cached briefly per cwd: it walks the tree and
+ *  spawns a process per checkout, while the panel polls several times a minute.
+ *  A submodule appearing or disappearing is a deliberate reconfiguration, so a
+ *  one-minute staleness is the right trade. */
+const repoScanCache = new Map()
+const REPO_SCAN_TTL_MS = 60_000
+
+async function scanRepos(cwd) {
+  const cached = repoScanCache.get(cwd)
+  /* Hand back fresh row objects: the cache is shared by every caller, and a
+     consumer that decorates or reorders what it received must not write
+     through into the next request's answer. */
+  if (cached !== undefined && cached.expires > Date.now()) return cached.rows.map((row) => ({ ...row }))
+  const list = []
+  const self = await runGit(cwd, ['rev-parse', '--show-toplevel'])
+  const isRepo = self.code === 0
+  if (isRepo) {
+    const top = self.stdout.trim()
+    list.push(repoRow(top === '' ? cwd : top, undefined, 'workspace'))
+  }
+  for (const dir of findNestedRepos(cwd, 2)) list.push(repoRow(dir, undefined, 'nested'))
+  /* Submodules of EVERY discovered checkout, not only a workspace that is one:
+     a container workspace (a folder holding several checkouts — the usual
+     shape of a multi-repo project) reaches its repositories through the rows
+     above, and each of those may carry submodules of its own. Without this
+     pass the picker lists `eis` but none of the eight checkouts under it.
+     These rows are built LAST and the map below lets them win: the directory
+     scan can reach the same checkout through a plain path (a submodule whose
+     parent directory is not itself a repository), and the submodule row is the
+     better one — its name carries the repo-relative path. */
+  const roots = list.map((row) => row.path)
+  const submoduleLists = await Promise.all(roots.map((root) => collectSubmoduleRepos(root)))
+  for (const entries of submoduleLists) {
+    for (const entry of entries) list.push(repoRow(entry.root, entry.rel, 'nested'))
+  }
+  const byIdentity = new Map()
+  for (const row of list) byIdentity.set(pathIdentity(row.path), row)
+  const rows = [...byIdentity.values()]
+  rows.sort((a, b) => (a.kind === b.kind ? a.path.localeCompare(b.path) : a.kind === 'workspace' ? -1 : 1))
+  const capped = rows.slice(0, REPO_LIST_LIMIT).map((row) => ({ ...row }))
+  const branches = await Promise.all(capped.map((row) => branchOrNull(row.path)))
+  for (let index = 0; index < capped.length; index += 1) capped[index].branch = branches[index]
+  repoScanCache.set(cwd, { rows: capped, expires: Date.now() + REPO_SCAN_TTL_MS })
+  return capped.map((row) => ({ ...row }))
+}
+
 /** Depth-capped search for repositories nested in a workspace. */
 function findNestedRepos(root, maxDepth) {
   const found = []
@@ -1077,25 +1209,18 @@ async function branchOrNull(root) {
 
 /**
  * Repositories this panel may bind to: the session workspace itself when it is
- * one, plus repositories nested inside it (a sandbox holding many checkouts).
- * The client turns this into the repo picker — an empty workspace is answered
- * with the picker, not with an error.
+ * one, repositories nested inside it (a sandbox holding many checkouts), and
+ * the submodules of every checkout discovered that way — git records each
+ * submodule as its own working tree with its own HEAD, index and branches, so
+ * it is a repository the panel can bind to like any other. The client turns
+ * this into the repo picker, and picking a row is all it takes: every later
+ * call carries that path as `repoRoot`, which is the working directory the git
+ * commands run in.
  */
 async function repos(payload) {
   const cwd = cwdOf(payload)
-  const list = []
-  const self = await runGit(cwd, ['rev-parse', '--show-toplevel'])
-  const isRepo = self.code === 0
-  if (isRepo) {
-    const top = self.stdout.trim()
-    list.push({ path: top, name: path.basename(top), branch: await branchOrNull(top), kind: 'workspace' })
-  }
-  for (const dir of findNestedRepos(cwd, 2)) {
-    if (list.some((entry) => entry.path === dir)) continue
-    list.push({ path: dir, name: path.basename(dir), branch: await branchOrNull(dir), kind: 'nested' })
-  }
-  list.sort((a, b) => (a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === 'workspace' ? -1 : 1))
-  return { cwd, isRepo, repos: list }
+  const rows = await scanRepos(cwd)
+  return { cwd, isRepo: rows.some((row) => row.kind === 'workspace'), repos: rows }
 }
 
 async function version() {