@goodandready/dsh-github-ops 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.5.0
+
+### Features
+- **Organization Repositories Status Matrix** (#48): Added `gh_matrix_status` tool and dedicated `/dsh-github-ops/matrix` route (plus `what=matrix` in sidebar panel) collecting releases/tags, npm published versions, CI workflow run status, and open issue counts with in-memory TTL caching and graceful degradation. Added interactive Organization Matrix mode and table with status badges in the sidebar panel.
+- **External GitHub Issues Triage to Gitea Registry** (#66): Added `gh_triage_external_issues` tool scanning public GitHub repositories for open issues, cross-referencing against Gitea issue tracker via issue URLs and markers, generating canonical 5-section draft issues with priority and type labels, and providing optional automated creation via `sync: true` and `confirm: true`.
+- **Visual Merge Conflict Resolution in Source Control** (#49): Added merge conflict hunk parsing (`parseConflictBlocks`, `hasConflicts`, `resolveConflictContent`) supporting both 2-way and diff3 markers. Added `resolveConflict` action with auto-staging (`git add`), conflict detection in SCM route, and interactive diff banner in the Web UI with one-click actions: "Accept Current (Ours)", "Accept Incoming (Theirs)", and "Accept Both".
+
 ## 0.4.1
 
 ### Fixed

package/lib/client.js

@@ -350,12 +350,24 @@ window.__ModuleLoader__.load({
 
       const openDiff = (file, staged) => {
         setSelected({ path: file.path, staged })
-        setDiff({ phase: 'loading', text: '' })
+        setDiff({ phase: 'loading', text: '', hasConflicts: false, conflicts: [] })
         const query = `?file=${encodeURIComponent(file.path)}${staged ? '&staged=1' : ''}${cwdQuery ? `&${cwdQuery}` : ''}`
         fetchWithTimeout(SCM_PATH + query, { headers: { accept: 'application/json' } })
           .then((response) => (response.ok ? response.json() : Promise.reject(new Error(`HTTP ${response.status}`))))
-          .then((payload) => setDiff({ phase: 'ready', text: payload.diff || '' }))
-          .catch((err) => setDiff({ phase: 'error', text: String((err && err.message) || err) }))
+          .then((payload) => setDiff({
+            phase: 'ready',
+            text: payload.diff || '',
+            hasConflicts: Boolean(payload.hasConflicts || (file.status === 'U') || (payload.diff && payload.diff.includes('<<<<<<<'))),
+            conflicts: payload.conflicts || [],
+          }))
+          .catch((err) => setDiff({ phase: 'error', text: String((err && err.message) || err), hasConflicts: false }))
+      }
+
+      const resolveConflict = (choice, blockIndex) => {
+        if (!selected || !selected.path) return
+        const args = { path: selected.path, choice }
+        if (blockIndex !== undefined && blockIndex !== null) args.blockIndex = blockIndex
+        runAction('resolveConflict', args)
       }
 
       const openStashDiff = (stashRef) => {
@@ -548,6 +560,16 @@ window.__ModuleLoader__.load({
         group(t('scmStaged'), files.staged, true),
         group(t('scmChanges'), files.changes, false),
         group(t('scmUntracked'), files.untracked, false),
+        selected && diff.hasConflicts
+          ? React.createElement('div', { className: 'gho-conflict-bar' },
+              React.createElement('span', { className: 'gho-conflict-title' }, t('scmConflictDetected')),
+              React.createElement('div', { className: 'gho-conflict-actions' },
+                button(t('scmAcceptCurrent'), () => resolveConflict('ours')),
+                button(t('scmAcceptIncoming'), () => resolveConflict('theirs')),
+                button(t('scmAcceptBoth'), () => resolveConflict('both')),
+              ),
+            )
+          : null,
         selected
           ? React.createElement('pre', { className: 'gho-scm-diff' },
             diff.phase === 'loading' ? t('scmLoading') : (diff.text || t('scmDiffEmpty')))
@@ -707,6 +729,7 @@ window.__ModuleLoader__.load({
         if (!repo) return
         if (tab === 'tree') loadTree('')
         else if (tab === 'inbox') loadInbox()
+        else if (tab === 'matrix') loadMatrix()
         else loadList(tab)
       }, [repo, tab, loadTree, loadList, loadInbox])
 
@@ -728,7 +751,11 @@ window.__ModuleLoader__.load({
       )
 
       const switcher = React.createElement('div', { className: 'gho-panel' },
-        React.createElement('div', { className: 'gho-panel-row' },
+        React.createElement('div', { className: 'gho-panel-tabs' },
+          React.createElement('button', { type: 'button', className: 'gho-panel-tab', 'aria-pressed': switchMode === 'repos', onClick: () => setSwitchMode('repos') }, t('panelRepo')),
+          React.createElement('button', { type: 'button', className: 'gho-panel-tab', 'aria-pressed': switchMode === 'matrix', onClick: () => { setSwitchMode('matrix'); if (matrix.phase === 'idle') loadMatrix() } }, t('panelMatrix')),
+        ),
+        switchMode === 'matrix' ? matrixView : React.createElement('div', { className: 'gho-panel-row' },
           React.createElement('input', {
             className: 'gho-panel-input',
             placeholder: t('panelSearch'),
@@ -778,6 +805,47 @@ window.__ModuleLoader__.load({
         file ? React.createElement('pre', { className: 'gho-panel-pre' }, file.truncated ? `${file.text}\n…` : (file.text || t('panelEmpty'))) : null,
       )
 
+            const matrixView = (() => {
+        if (matrix.phase === 'loading') return React.createElement('div', { className: 'gho-panel-muted' }, t('panelLoading'))
+        if (!matrix.list.length) return React.createElement('div', { className: 'gho-panel-muted' }, t('panelMatrixEmpty'))
+        return React.createElement('table', { className: 'gho-matrix-table' },
+          React.createElement('thead', null,
+            React.createElement('tr', null,
+              React.createElement('th', { className: 'gho-matrix-th' }, t('panelMatrixRepo')),
+              React.createElement('th', { className: 'gho-matrix-th' }, t('panelMatrixStatus')),
+              React.createElement('th', { className: 'gho-matrix-th' }, t('panelMatrixRelease')),
+              React.createElement('th', { className: 'gho-matrix-th' }, t('panelMatrixNpm')),
+              React.createElement('th', { className: 'gho-matrix-th' }, t('panelMatrixCi')),
+              React.createElement('th', { className: 'gho-matrix-th' }, t('panelMatrixIssues')),
+              React.createElement('th', { className: 'gho-matrix-th' }, ''),
+            ),
+          ),
+          React.createElement('tbody', null,
+            matrix.list.map((row) => React.createElement('tr', { key: row.fullName || row.name },
+              React.createElement('td', { className: 'gho-matrix-td' },
+                React.createElement('button', {
+                  type: 'button',
+                  className: 'gho-link',
+                  style: { margin: 0, fontWeight: 600, textAlign: 'left' },
+                  title: t('panelMatrixSelect'),
+                  onClick: () => { setRepo(row.fullName || row.name); setTab('tree'); setFile(null) },
+                }, row.name || row.fullName),
+              ),
+              React.createElement('td', { className: 'gho-matrix-td' },
+                React.createElement('span', { className: `gho-badge gho-badge-${row.status || 'active'}` }, row.status || 'active'),
+              ),
+              React.createElement('td', { className: 'gho-matrix-td' }, (row.release && row.release.tag) || '—'),
+              React.createElement('td', { className: 'gho-matrix-td' }, (row.npm && row.npm.version) || '—'),
+              React.createElement('td', { className: 'gho-matrix-td' }, (row.ci && (row.ci.conclusion || row.ci.status)) || '—'),
+              React.createElement('td', { className: 'gho-matrix-td' }, String(row.openIssuesCount || 0)),
+              React.createElement('td', { className: 'gho-matrix-td' },
+                row.htmlUrl ? React.createElement('a', { className: 'gho-link', href: row.htmlUrl, target: '_blank', rel: 'noreferrer' }, '↗') : null,
+              ),
+            )),
+          ),
+        )
+      })()
+
       return React.createElement('div', { className: 'gho-panel' },
         header,
         React.createElement('div', { className: 'gho-panel-tabs' },
@@ -786,10 +854,11 @@ window.__ModuleLoader__.load({
           tabButton('pulls', t('panelPulls')),
           tabButton('runs', t('panelRuns')),
           tabButton('inbox', t('panelInbox')),
+          tabButton('matrix', t('panelMatrix')),
           React.createElement('button', { type: 'button', className: 'gho-panel-tab', onClick: () => { setRepo(''); setFile(null) } }, t('panelRepo')),
         ),
         error ? React.createElement('div', { className: 'gho-panel-muted' }, error) : null,
-        tab === 'tree' ? treeView : list,
+        tab === 'tree' ? treeView : (tab === 'matrix' ? matrixView : list),
       )
     }
 
@@ -818,6 +887,18 @@ window.__ModuleLoader__.load({
         '.gho-status-value{color:var(--dsw-alias-label-primary);font-variant-numeric:tabular-nums}',
         '.gho-status-head{display:flex;align-items:center;gap:8px;font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary)}',
         '.gho-status-bad{color:var(--dsw-alias-label-error)}',
+        '.gho-badge{display:inline-block;padding:2px 6px;border-radius:4px;font-size:10px;font-weight:600;text-transform:uppercase}',
+        '.gho-badge-healthy{background:var(--dsw-alias-color-success-bg,rgba(46,160,67,0.15));color:var(--dsw-alias-color-success,#2ea043)}',
+        '.gho-badge-failing{background:var(--dsw-alias-color-danger-bg,rgba(248,81,73,0.15));color:var(--dsw-alias-label-error,#f85149)}',
+        '.gho-badge-building{background:var(--dsw-alias-color-warning-bg,rgba(210,153,34,0.15));color:var(--dsw-alias-color-warning,#d29922)}',
+        '.gho-badge-released{background:var(--dsw-alias-color-info-bg,rgba(56,139,253,0.15));color:var(--dsw-alias-color-info,#388bfd)}',
+        '.gho-badge-active{background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-secondary)}',
+        '.gho-matrix-table{width:100%;border-collapse:collapse;font-size:11px;margin-top:6px}',
+        '.gho-matrix-th{text-align:left;padding:4px 6px;border-bottom:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-secondary)}',
+        '.gho-matrix-td{padding:5px 6px;border-bottom:1px solid var(--dsw-alias-border-l2);vertical-align:middle}',
+        '.gho-conflict-bar{display:flex;align-items:center;gap:10px;padding:8px 12px;background:var(--dsw-alias-color-warning-bg,rgba(210,153,34,0.15));border:1px solid var(--dsw-alias-color-warning,#d29922);border-radius:8px;margin-bottom:6px}',
+        '.gho-conflict-title{font-weight:600;font-size:12px;color:var(--dsw-alias-label-primary)}',
+        '.gho-conflict-actions{display:flex;gap:6px;margin-left:auto}',
         '.gho-link{appearance:none;border:0;background:0 0;font:inherit;font-size:12px;color:var(--dsw-alias-label-secondary);text-decoration:underline;cursor:pointer;padding:0;margin-left:auto}',
         '.gho-scm{display:flex;flex-direction:column;gap:12px;padding:4px 2px;font-size:13px;color:var(--dsw-alias-label-primary)}',
         '.gho-scm-head{display:flex;align-items:center;gap:10px;flex-wrap:wrap}',

package/lib/routes.js

@@ -5,16 +5,17 @@
 // stays a composition: the card, the Source Control tab and the sidebar panel each need one
 // endpoint, and none of them needs a tool.
 
-import { existsSync, statSync } from 'node:fs'
+import { existsSync, statSync, readFileSync } from 'node:fs'
 import { join as joinPath } from 'node:path'
 
 import { statusPayload, isTrustedRequest, isTrustedWriteRequest, sendJson } from './status.js'
-import { buildAction, validateCwd, validateStashRef } from './scm-write.js'
-import { parseStatus, parseBranches, parseStashes, parseWorktrees, parseCount, scmPayload, mergeStateFrom } from './scm.js'
+import { buildAction, validateCwd, validateStashRef, resolveConflictFile } from './scm-write.js'
+import { parseStatus, parseBranches, parseStashes, parseWorktrees, parseCount, scmPayload, mergeStateFrom, hasConflicts, parseConflictBlocks } from './scm.js'
 import { listIssues } from './tools/issues.js'
 import { listRuns } from './tools/actions.js'
 import { listNotifications, repoTreeView } from './tools/panel-data.js'
 import { mirrorStatus, syncMirror } from './tools/mirror.js'
+import { matrixStatus } from './tools/matrix.js'
 
 /** Where the settings card reads the access status from. */
 export const STATUS_PATH = '/dsh-github-ops/status'
@@ -28,6 +29,9 @@ export const PANEL_PATH = '/dsh-github-ops/panel'
 /** Where mirror inspection and sync are handled. */
 export const MIRROR_PATH = '/dsh-github-ops/mirror'
 
+/** Where organization matrix status is read. */
+export const MATRIX_PATH = '/dsh-github-ops/matrix'
+
 /**
  * Register the three routes.
  *
@@ -157,6 +161,19 @@ export function registerRoutes(ctx, deps = {}) {
             } catch (err) {
               return sendJson(res, 400, { ok: false, error: String((err && err.message) || err) })
             }
+            if (built.action === 'resolveConflict') {
+              try {
+                const actionArgs = body.args || body
+                resolveConflictFile({
+                  cwd,
+                  path: actionArgs.path,
+                  choice: actionArgs.choice,
+                  blockIndex: actionArgs.blockIndex,
+                })
+              } catch (err) {
+                return sendJson(res, 400, { ok: false, error: String((err && err.message) || err) })
+              }
+            }
             const steps = []
             for (const argv of built.steps) {
               const answer = await git(argv, { cwd, timeoutMs: 120000 })
@@ -178,7 +195,27 @@ export function registerRoutes(ctx, deps = {}) {
             const args = staged ? ['diff', '--cached', '--', file] : ['diff', '--', file]
             const diff = await git(args, { cwd })
             const text = diff.code === 0 ? diff.stdout : diff.stderr
-            return sendJson(res, 200, { file, staged, diff: String(text || '').slice(0, 200000) })
+            let hasConflictsFlag = false
+            let conflicts = []
+            try {
+              const fullFilePath = joinPath(cwd, file)
+              if (existsSync(fullFilePath)) {
+                const content = readFileSync(fullFilePath, 'utf8')
+                if (hasConflicts(content)) {
+                  hasConflictsFlag = true
+                  conflicts = parseConflictBlocks(content)
+                }
+              }
+            } catch {
+              // ignore
+            }
+            return sendJson(res, 200, {
+              file,
+              staged,
+              diff: String(text || '').slice(0, 200000),
+              hasConflicts: hasConflictsFlag,
+              conflicts,
+            })
           }
 
           const stash = url.searchParams.get('stash') || ''
@@ -280,6 +317,12 @@ export function registerRoutes(ctx, deps = {}) {
               const { data } = await github.get('/user/repos', { query: { per_page: 50, sort: 'pushed', affiliation: 'owner,collaborator,organization_member' } })
               return sendJson(res, 200, { configured: true, repos: (data || []).filter((r) => !r.archived).map((r) => ({ fullName: r.full_name, private: r.private, pushedAt: r.pushed_at, description: r.description || '', stars: r.stargazers_count })) })
             }
+            if (what === 'matrix') {
+              const org = url.searchParams.get('org') || repoOwner || liveConfig().owner || ''
+              const limit = Number(url.searchParams.get('limit')) || 30
+              const result = await matrixStatus(github, { org, limit })
+              return sendJson(res, 200, { configured: true, ...result })
+            }
             if (!repoOwner || !repoName) return sendJson(res, 200, { configured: true, error: 'a repository is required for this view' })
             const repo = { owner: repoOwner, repo: repoName }
             if (what === 'tree') {
@@ -311,6 +354,7 @@ export function registerRoutes(ctx, deps = {}) {
               const result = await listNotifications(github, { limit: 30 })
               return sendJson(res, 200, { configured: true, ...result })
             }
+
             return sendJson(res, 200, { configured: true, error: `unknown view "${what}"` })
           } catch (err) {
             return sendJson(res, 200, { configured: true, error: describeError(err) })
@@ -390,6 +434,30 @@ export function registerRoutes(ctx, deps = {}) {
       })
       if (typeof wctx.effect === 'function') wctx.effect(registerMirror, 'dsh-github-ops: mirror route')
       else registerMirror()
+
+      const registerMatrix = () => wctx.webServer.register({
+        kind: 'exact',
+        path: MATRIX_PATH,
+        handler: async (req, res) => {
+          try {
+            if (req.method !== 'GET') return sendJson(res, 405, { error: 'method not allowed' })
+            if (!isTrustedRequest(req)) return sendJson(res, 403, { error: 'forbidden' })
+            const access = await resolveToken()
+            if (!access.value) return sendJson(res, 200, { configured: false, guidance: access.guidance })
+            const url = new URL(req.url || '/', 'http://localhost')
+            const org = url.searchParams.get('org') || liveConfig().owner || ''
+            const limit = Number(url.searchParams.get('limit')) || 30
+            const github = await client()
+            const result = await matrixStatus(github, { org, limit })
+            return sendJson(res, 200, { ok: true, ...result })
+          } catch (err) {
+            return sendJson(res, 500, { ok: false, error: describeError(err) })
+          }
+        },
+      })
+      if (typeof wctx.effect === 'function') wctx.effect(registerMatrix, 'dsh-github-ops: matrix route')
+      else registerMatrix()
+
     } catch (err) {
       ctx.logger?.warn?.('[dsh-github-ops] panel route not registered:', err && err.message)
     }

package/lib/scm-write.js

@@ -1,4 +1,6 @@
-import { realpathSync } from 'node:fs'
+import { realpathSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join as joinPath } from 'node:path'
+import { hasConflicts, resolveConflictContent } from './scm.js'
 // Writing to a working copy, from the Source Control tab.
 //
 // Every action is a list of argv arrays — never a shell string. The route runs them one by one
@@ -114,6 +116,14 @@ export function buildAction(action, args = {}) {
       if (!CONTINUE_VERBS.includes(verb)) throw new Error(`refusing to abort an unknown operation: "${verb.slice(0, 20)}"`)
       return result(name, [[verb, '--abort']], destructive, `abort the ${verb}`)
     }
+    case 'resolveConflict': {
+      const path = validatePath(args.path)
+      const choice = String(args.choice || 'ours').trim()
+      if (!['ours', 'theirs', 'both'].includes(choice)) {
+        throw new Error(`invalid conflict resolution choice: "${choice}". Must be "ours", "theirs", or "both".`)
+      }
+      return result(name, [['add', '--', path]], false, `resolve conflict in ${path} using ${choice}`)
+    }
     case 'worktreeAdd': {
       const path = validateCwd(args.path)
       if (!path) throw new Error('worktree path is required')
@@ -156,6 +166,7 @@ export const ACTIONS = Object.freeze([
   'stashPush', 'stashApply', 'stashPop', 'stashDrop', 'stashShow',
   'worktreeAdd', 'worktreeRemove',
   'continue', 'abort',
+  'resolveConflict',
 ])
 
 /** The verbs the panel offers for an unfinished operation. */
@@ -193,3 +204,22 @@ export function validateCwd(path) {
   }
   return value
 }
+
+
+/**
+ * Resolves conflict markers directly in the working copy file and prepares it for staging.
+ */
+export function resolveConflictFile({ cwd, path, choice = 'ours', blockIndex = null }) {
+  const relPath = validatePath(path)
+  const fullPath = joinPath(cwd, relPath)
+  if (!existsSync(fullPath)) {
+    throw new Error(`file not found: ${relPath}`)
+  }
+  const content = readFileSync(fullPath, 'utf8')
+  if (!hasConflicts(content)) {
+    throw new Error(`no merge conflict markers found in ${relPath}`)
+  }
+  const resolved = resolveConflictContent(content, { choice, blockIndex })
+  writeFileSync(fullPath, resolved, 'utf8')
+  return { path: relPath, choice, blockIndex, resolved: true }
+}

package/lib/scm.js

@@ -150,3 +150,187 @@ export function mergeStateFrom({ mergeHead = false, rebaseDir = false, cherryPic
   if (revertHead) return { inProgress: true, kind: 'revert' }
   return { inProgress: false, kind: '' }
 }
+
+
+const CONFLICT_START_RE = /^<<<<<<<[ \t]*(.*)$/
+const CONFLICT_BASE_RE = /^\|\|\|\|\|\|\|[ \t]*(.*)$/
+const CONFLICT_MID_RE = /^=======$/
+const CONFLICT_END_RE = /^>>>>>>>[ \t]*(.*)$/
+
+/**
+ * Check whether a string contains merge conflict markers.
+ */
+export function hasConflicts(content) {
+  if (!content || typeof content !== 'string') return false
+  return content.includes('<<<<<<<') && content.includes('=======') && content.includes('>>>>>>>')
+}
+
+/**
+ * Parse conflict hunks/blocks from file content.
+ */
+export function parseConflictBlocks(content) {
+  if (!hasConflicts(content)) return []
+  const lines = String(content).split(/\r?\n/)
+  const blocks = []
+
+  let inBlock = false
+  let inBase = false
+  let inTheirs = false
+
+  let startLine = 0
+  let oursHeader = ''
+  let baseHeader = ''
+  let theirsHeader = ''
+  let oursLines = []
+  let baseLines = []
+  let theirsLines = []
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const lineNum = i + 1
+
+    if (!inBlock) {
+      const match = CONFLICT_START_RE.exec(line)
+      if (match) {
+        inBlock = true
+        inBase = false
+        inTheirs = false
+        startLine = lineNum
+        oursHeader = match[1] || 'HEAD'
+        baseHeader = ''
+        theirsHeader = ''
+        oursLines = []
+        baseLines = []
+        theirsLines = []
+      }
+    } else if (!inTheirs) {
+      const baseMatch = CONFLICT_BASE_RE.exec(line)
+      if (baseMatch) {
+        inBase = true
+        baseHeader = baseMatch[1] || ''
+        continue
+      }
+      if (CONFLICT_MID_RE.test(line)) {
+        inTheirs = true
+        inBase = false
+        continue
+      }
+      if (inBase) {
+        baseLines.push(line)
+      } else {
+        oursLines.push(line)
+      }
+    } else {
+      const endMatch = CONFLICT_END_RE.exec(line)
+      if (endMatch) {
+        theirsHeader = endMatch[1] || ''
+        const oursStr = oursLines.join('\n')
+        const theirsStr = theirsLines.join('\n')
+        const baseStr = baseLines.length > 0 ? baseLines.join('\n') : undefined
+        const bothStr = [oursStr, theirsStr].filter((s) => s.length > 0).join('\n')
+
+        blocks.push({
+          index: blocks.length,
+          startLine,
+          endLine: lineNum,
+          oursHeader,
+          theirsHeader,
+          baseHeader: baseHeader || undefined,
+          ours: oursStr,
+          theirs: theirsStr,
+          base: baseStr,
+          both: bothStr,
+        })
+
+        inBlock = false
+        inBase = false
+        inTheirs = false
+      } else {
+        theirsLines.push(line)
+      }
+    }
+  }
+
+  return blocks
+}
+
+/**
+ * Resolve merge conflict markers to chosen resolution: 'ours', 'theirs', or 'both'.
+ */
+export function resolveConflictContent(content, resolutions = 'ours') {
+  if (!hasConflicts(content)) return content
+  const eol = content.includes('\r\n') ? '\r\n' : '\n'
+  const lines = String(content).split(/\r?\n/)
+  const resultLines = []
+
+  let inBlock = false
+  let inBase = false
+  let inTheirs = false
+  let blockIndex = 0
+
+  let oursLines = []
+  let theirsLines = []
+
+  const getChoice = (idx) => {
+    if (typeof resolutions === 'string') return resolutions
+    if (resolutions && typeof resolutions === 'object') {
+      if (Array.isArray(resolutions)) {
+        const found = resolutions.find((r) => r.blockIndex === idx)
+        return found ? found.choice : null
+      }
+      if (resolutions.blockIndex === idx) return resolutions.choice
+      if (resolutions.blockIndex === null || resolutions.blockIndex === undefined) return resolutions.choice
+    }
+    return null
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    if (!inBlock) {
+      if (CONFLICT_START_RE.test(line)) {
+        inBlock = true
+        inBase = false
+        inTheirs = false
+        oursLines = []
+        theirsLines = []
+      } else {
+        resultLines.push(line)
+      }
+    } else if (!inTheirs) {
+      if (CONFLICT_BASE_RE.test(line)) {
+        inBase = true
+      } else if (CONFLICT_MID_RE.test(line)) {
+        inTheirs = true
+        inBase = false
+      } else if (!inBase) {
+        oursLines.push(line)
+      }
+    } else {
+      if (CONFLICT_END_RE.test(line)) {
+        const choice = getChoice(blockIndex)
+        if (choice === 'theirs') {
+          resultLines.push(...theirsLines)
+        } else if (choice === 'both') {
+          if (oursLines.length) resultLines.push(...oursLines)
+          if (theirsLines.length) resultLines.push(...theirsLines)
+        } else if (choice === 'ours') {
+          resultLines.push(...oursLines)
+        } else {
+          resultLines.push('<<<<<<< HEAD')
+          resultLines.push(...oursLines)
+          resultLines.push('=======')
+          resultLines.push(...theirsLines)
+          resultLines.push('>>>>>>> incoming')
+        }
+        blockIndex++
+        inBlock = false
+        inTheirs = false
+      } else {
+        theirsLines.push(line)
+      }
+    }
+  }
+
+  return resultLines.join(eol)
+}

package/lib/tools/matrix.js

@@ -0,0 +1,229 @@
+// Organization repositories status matrix: releases, npm versions, CI status and issues.
+//
+// Read-only, concurrency-batched, cached with TTL to preserve GitHub rate limits.
+
+const MATRIX_CACHE = new Map()
+
+export function clearMatrixCache() {
+  MATRIX_CACHE.clear()
+}
+
+/**
+ * Determine health status badge based on CI, releases, issues.
+ */
+function deriveStatus(release, ci, openIssuesCount) {
+  if (ci && (ci.conclusion === 'failure' || ci.conclusion === 'timed_out')) return 'failing'
+  if (ci && (ci.status === 'in_progress' || ci.status === 'queued')) return 'building'
+  if (ci && ci.conclusion === 'success') return 'healthy'
+  if (release) return 'released'
+  return 'active'
+}
+
+/**
+ * Fetch published package metadata from npm registry.
+ */
+async function fetchNpmVersion(pkgName, fetchFn = globalThis.fetch) {
+  if (!pkgName || typeof fetchFn !== 'function') return null
+  try {
+    const encoded = pkgName.startsWith('@')
+      ? `@${encodeURIComponent(pkgName.slice(1))}`
+      : encodeURIComponent(pkgName)
+    const url = `https://registry.npmjs.org/${encoded}`
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
+    const timer = controller ? setTimeout(() => controller.abort(), 4000) : null
+    const res = await fetchFn(url, {
+      headers: { accept: 'application/json' },
+      signal: controller ? controller.signal : undefined,
+    })
+    if (timer) clearTimeout(timer)
+    if (!res.ok) return null
+    const data = await res.json()
+    const latest = data['dist-tags']?.latest || data.version
+    return latest ? { name: pkgName, version: latest } : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Gather organization matrix status.
+ */
+export async function matrixStatus(client, options = {}, deps = {}) {
+  const {
+    org = '',
+    limit = 30,
+    includeNpm = true,
+    includeCi = true,
+    includeReleases = true,
+    cacheTtlMs = 60000,
+  } = options
+  const { fetchFn = globalThis.fetch } = deps
+
+  const cappedLimit = Math.max(1, Math.min(Number(limit) || 30, 100))
+
+  // Determine target org / user
+  let targetOrg = String(org || '').trim()
+  if (!targetOrg) {
+    try {
+      const userRes = await client.get('/user')
+      targetOrg = userRes.data?.login || ''
+    } catch {
+      targetOrg = ''
+    }
+  }
+  if (!targetOrg) {
+    throw new Error('an organization or user name is required')
+  }
+
+  // Check cache
+  const cacheKey = `${targetOrg}:${cappedLimit}:${includeNpm}:${includeCi}:${includeReleases}`
+  const cached = MATRIX_CACHE.get(cacheKey)
+  if (cached && (Date.now() - cached.timestamp < cacheTtlMs)) {
+    return { ...cached.data, cached: true }
+  }
+
+  // Fetch repositories
+  let rawRepos = []
+  try {
+    const orgRes = await client.get(`/orgs/${targetOrg}/repos`, {
+      query: { per_page: cappedLimit, sort: 'pushed', direction: 'desc' },
+    })
+    rawRepos = Array.isArray(orgRes.data) ? orgRes.data : []
+  } catch (err) {
+    // Fallback to user repos if not an org
+    try {
+      const userRes = await client.get(`/users/${targetOrg}/repos`, {
+        query: { per_page: cappedLimit, sort: 'pushed', direction: 'desc' },
+      })
+      rawRepos = Array.isArray(userRes.data) ? userRes.data : []
+    } catch {
+      rawRepos = []
+    }
+  }
+
+  const repos = rawRepos.filter((r) => !r.archived).slice(0, cappedLimit)
+
+  // Concurrency batching: process in chunks of 5
+  const matrix = []
+  const chunkSize = 5
+
+  for (let i = 0; i < repos.length; i += chunkSize) {
+    const chunk = repos.slice(i, i + chunkSize)
+    const chunkResults = await Promise.all(
+      chunk.map(async (repo) => {
+        const owner = repo.owner?.login || targetOrg
+        const repoName = repo.name
+
+        let release = null
+        let ci = null
+        let npm = null
+        let repoError = null
+
+        // 1. Release / Tag
+        if (includeReleases) {
+          try {
+            const relRes = await client.get(`/repos/${owner}/${repoName}/releases/latest`)
+            if (relRes.data && relRes.data.tag_name) {
+              release = {
+                tag: relRes.data.tag_name,
+                name: relRes.data.name || relRes.data.tag_name,
+                publishedAt: relRes.data.published_at,
+                prerelease: Boolean(relRes.data.prerelease),
+                htmlUrl: relRes.data.html_url,
+              }
+            }
+          } catch {
+            // Fallback to tags
+            try {
+              const tagsRes = await client.get(`/repos/${owner}/${repoName}/tags`, { query: { per_page: 1 } })
+              if (Array.isArray(tagsRes.data) && tagsRes.data[0]) {
+                const tag = tagsRes.data[0]
+                release = {
+                  tag: tag.name,
+                  name: tag.name,
+                  htmlUrl: `${repo.html_url}/releases/tag/${tag.name}`,
+                }
+              }
+            } catch {
+              // no release or tag
+            }
+          }
+        }
+
+        // 2. Latest CI Run
+        if (includeCi) {
+          try {
+            const runsRes = await client.get(`/repos/${owner}/${repoName}/actions/runs`, { query: { per_page: 1 } })
+            const runs = runsRes.data?.workflow_runs
+            if (Array.isArray(runs) && runs[0]) {
+              const run = runs[0]
+              ci = {
+                id: run.id,
+                name: run.name || 'CI',
+                status: run.status,
+                conclusion: run.conclusion,
+                htmlUrl: run.html_url,
+                createdAt: run.created_at,
+              }
+            }
+          } catch {
+            // CI not available or actions disabled
+          }
+        }
+
+        // 3. npm version
+        if (includeNpm) {
+          // Check package.json in repo first for exact name
+          let pkgName = `@${targetOrg}/${repoName}`
+          try {
+            const pkgFileRes = await client.get(`/repos/${owner}/${repoName}/contents/package.json`)
+            if (pkgFileRes.data && pkgFileRes.data.content) {
+              const raw = Buffer.from(pkgFileRes.data.content, 'base64').toString('utf8')
+              const parsed = JSON.parse(raw)
+              if (parsed.name) pkgName = parsed.name
+            }
+          } catch {
+            // package.json missing or unparseable
+          }
+
+          npm = await fetchNpmVersion(pkgName, fetchFn)
+          if (!npm && pkgName !== repoName) {
+            npm = await fetchNpmVersion(repoName, fetchFn)
+          }
+        }
+
+        const openIssuesCount = Number(repo.open_issues_count) || 0
+        const status = deriveStatus(release, ci, openIssuesCount)
+
+        return {
+          name: repoName,
+          fullName: repo.full_name || `${owner}/${repoName}`,
+          private: Boolean(repo.private),
+          description: repo.description || '',
+          stars: repo.stargazers_count || 0,
+          openIssuesCount,
+          defaultBranch: repo.default_branch || 'main',
+          pushedAt: repo.pushed_at,
+          htmlUrl: repo.html_url,
+          release,
+          ci,
+          npm,
+          status,
+          error: repoError,
+        }
+      })
+    )
+    matrix.push(...chunkResults)
+  }
+
+  const resultData = {
+    org: targetOrg,
+    totalRepos: matrix.length,
+    cached: false,
+    timestamp: new Date().toISOString(),
+    matrix,
+  }
+
+  MATRIX_CACHE.set(cacheKey, { timestamp: Date.now(), data: resultData })
+  return resultData
+}

package/lib/tools/register-collab.js

@@ -1,3 +1,4 @@
+import { triageExternalIssues } from './triage.js'
 // Collaboration tool registrations: issues, pull requests, reviews and checks.
 //
 // Reads are free; every write goes through the caller's confirmation contour in the
@@ -356,4 +357,30 @@ export function registerCollabTools({ tool, asRepo, client, liveConfig, reviewRu
       owner, repo, number: args.number,
     })),
   )
+
+  // ------------------------------------------------------------- triage
+
+  tool(
+    'gh_triage_external_issues',
+    'Triage external GitHub issues into the Gitea issue tracker. Compares GitHub issues against existing Gitea tasks and prepares canonical issue drafts. Set sync: true with confirm: true to create missing tasks in Gitea.',
+    repoParams({
+      giteaOwner: { type: 'string', description: 'Target Gitea repository owner (default "goodandready").' },
+      giteaRepo: { type: 'string', description: 'Target Gitea repository name (defaults to repository name).' },
+      state: { type: 'string', description: 'GitHub issue state: open (default), closed, or all.' },
+      limit: { type: 'number', description: 'Max issues to triage (default 20, max 50).' },
+      sync: { type: 'boolean', description: 'Create missing issues in Gitea tracker (default false).' },
+      confirm: { type: 'boolean', description: 'Required when sync is true.' },
+      giteaBaseUrl: { type: 'string', description: 'Gitea API base URL (default "http://127.0.0.1:3005").' },
+    }),
+    async (args) => withRepo(args, async ({ owner, repo }) => triageExternalIssues(await client(), {
+      repository: `${owner}/${repo}`,
+      giteaOwner: args.giteaOwner,
+      giteaRepo: args.giteaRepo,
+      state: args.state,
+      limit: args.limit,
+      sync: args.sync === true,
+      confirm: args.confirm === true,
+      giteaBaseUrl: args.giteaBaseUrl,
+    })),
+  )
 }

package/lib/tools/register-ops.js

@@ -1,3 +1,4 @@
+import { matrixStatus } from './matrix.js'
 // Workflow-run and repository-settings tool registrations.
 //
 // Reads are free; writes follow the plugin's model — an explicit confirm flag for the
@@ -325,4 +326,31 @@ export function registerOpsTools({ tool, asRepo, client, liveConfig }) {
       return withRepo(args, async ({ owner, repo }) => deleteBranchProtection(await client(), { owner, repo, branch: args.branch }))
     },
   )
+
+  // -------------------------------------------------------- matrix status
+
+  tool(
+    'gh_matrix_status',
+    'Get organization repositories status matrix: latest release/tag, npm version, CI status and open issues. Read-only.',
+    {
+      org: { type: 'string', description: 'Organization or user name. Omit to infer from settings or current account.' },
+      limit: { type: 'number', description: 'Max repositories to inspect (default 30, max 100).' },
+      includeNpm: { type: 'boolean', description: 'Query npm registry for published version (default true).' },
+      includeCi: { type: 'boolean', description: 'Query GitHub Actions for latest workflow run status (default true).' },
+      includeReleases: { type: 'boolean', description: 'Query latest release or tag (default true).' },
+      cacheTtlMs: { type: 'number', description: 'Cache TTL in milliseconds (default 60000).' },
+    },
+    async (args) => {
+      const cfg = typeof liveConfig === 'function' ? liveConfig() : {}
+      const targetOrg = args.org || cfg.owner || ''
+      return matrixStatus(await client(), {
+        org: targetOrg,
+        limit: args.limit,
+        includeNpm: args.includeNpm !== false,
+        includeCi: args.includeCi !== false,
+        includeReleases: args.includeReleases !== false,
+        cacheTtlMs: args.cacheTtlMs,
+      })
+    },
+  )
 }

package/lib/tools/triage.js

@@ -0,0 +1,213 @@
+// Triage external GitHub issues into the local Gitea project registry.
+//
+// Reads public GitHub issues, identifies whether they have already been triaged
+// into Gitea, drafts canonical issues conforming to the project standard, and optionally
+// creates missing issues when sync: true and confirm: true are supplied.
+
+import { existsSync, readFileSync } from 'node:fs'
+
+export function resolveGiteaToken(explicitToken) {
+  if (explicitToken) return explicitToken
+  if (typeof process !== 'undefined' && process.env?.GITEA_TOKEN) {
+    return process.env.GITEA_TOKEN
+  }
+  try {
+    const credPath = '/mnt/external/Project/DEV/.gitea-agent-credentials.json'
+    if (existsSync(credPath)) {
+      const data = JSON.parse(readFileSync(credPath, 'utf8'))
+      return data.agents?.antigravity?.token || ''
+    }
+  } catch {
+    // ignore
+  }
+  return ''
+}
+
+export function formatGiteaDraft({ owner, repo, issue }) {
+  const isBug = (issue.labels || []).some((l) => {
+    const name = (typeof l === 'string' ? l : l.name || '').toLowerCase()
+    return name.includes('bug') || name.includes('fix') || name.includes('error')
+  })
+  const isHigh = (issue.labels || []).some((l) => {
+    const name = (typeof l === 'string' ? l : l.name || '').toLowerCase()
+    return name.includes('critical') || name.includes('urgent') || name.includes('security')
+  })
+
+  const priorityPrefix = isHigh ? 'H:' : 'M:'
+  const priorityLabel = isHigh ? 'priority/high' : 'priority/medium'
+  const typeLabel = isBug ? 'type/bug' : 'type/feature'
+  const typeStr = isBug ? 'fix' : 'feat'
+
+  const title = `${priorityPrefix} ${typeStr}(ext): ${issue.title} (GH#${issue.number})`
+
+  const body = [
+    '### 1. Источник и контекст',
+    `Входящая внешняя issue: [${owner}/${repo}#${issue.number}](${issue.html_url})`,
+    `Автор: @${(issue.user && issue.user.login) || 'unknown'}`,
+    `Создана: ${issue.created_at || 'unknown'}`,
+    '',
+    '### 2. Описание проблемы',
+    issue.body ? issue.body.trim() : 'Описание отсутствует.',
+    '',
+    '### 3. Что должно быть сделано',
+    '- Проанализировать входящий сигнал из внешнего GitHub-репозитория.',
+    '- Определить применимость в локальном проекте Gitea.',
+    '- Реализовать решение или сформировать обоснованный ответ.',
+    '',
+    '### 4. Критерии приёмки',
+    '- Решение протестировано при внедрении.',
+    '- Первоисточник связан и закрыт после релиза.',
+  ].join('\n')
+
+  return {
+    title,
+    body,
+    labels: [priorityLabel, typeLabel, 'status/confirmed'],
+  }
+}
+
+export function isAlreadyTriaged(ghIssue, giteaIssues, { owner, repo }) {
+  const ghNumber = Number(ghIssue.number)
+  const ghUrl = `github.com/${owner}/${repo}/issues/${ghNumber}`
+  const ghMarker = `GH#${ghNumber}`
+  const ghTag = `[GH-${ghNumber}]`
+  const ghAlt = `(GH#${ghNumber})`
+
+  for (const gi of giteaIssues) {
+    const title = gi.title || ''
+    const body = gi.body || ''
+    if (
+      body.includes(ghUrl) ||
+      title.includes(ghMarker) ||
+      title.includes(ghTag) ||
+      title.includes(ghAlt) ||
+      body.includes(ghMarker) ||
+      body.includes(ghTag)
+    ) {
+      return { triaged: true, giteaIssueNumber: gi.number, giteaIssueUrl: gi.html_url }
+    }
+  }
+  return { triaged: false, giteaIssueNumber: null, giteaIssueUrl: null }
+}
+
+export async function triageExternalIssues(client, options = {}, deps = {}) {
+  const {
+    repository = '',
+    giteaOwner = 'goodandready',
+    giteaRepo = '',
+    state = 'open',
+    limit = 20,
+    sync = false,
+    confirm = false,
+    giteaBaseUrl = 'http://127.0.0.1:3005',
+    giteaToken = '',
+  } = options
+  const { fetchFn = globalThis.fetch, giteaClient = null } = deps
+
+  if (!repository || !repository.includes('/')) {
+    throw new Error('repository must be in "owner/repo" format')
+  }
+  const [owner, repo] = repository.split('/')
+  const targetGiteaRepo = giteaRepo || repo
+
+  if (sync && confirm !== true) {
+    throw new Error('confirm: true is required when sync is true to create issues in Gitea')
+  }
+
+  const cappedLimit = Math.max(1, Math.min(Number(limit) || 20, 50))
+
+  // 1. Fetch GitHub issues
+  const { data: rawIssues } = await client.get(`/repos/${owner}/${repo}/issues`, {
+    query: { state, per_page: cappedLimit, sort: 'created', direction: 'desc' },
+  })
+  const ghIssues = (Array.isArray(rawIssues) ? rawIssues : [])
+    .filter((i) => !i.pull_request)
+    .slice(0, cappedLimit)
+
+  // 2. Fetch Gitea issues
+  let giteaIssues = []
+  const token = resolveGiteaToken(giteaToken)
+
+  if (giteaClient && typeof giteaClient.getIssues === 'function') {
+    giteaIssues = await giteaClient.getIssues({ owner: giteaOwner, repo: targetGiteaRepo })
+  } else if (typeof fetchFn === 'function') {
+    try {
+      const giteaUrl = `${giteaBaseUrl.replace(/\/$/, '')}/api/v1/repos/${giteaOwner}/${targetGiteaRepo}/issues?state=all&limit=100`
+      const headers = { accept: 'application/json' }
+      if (token) headers.authorization = `token ${token}`
+      const res = await fetchFn(giteaUrl, { headers })
+      if (res.ok) {
+        giteaIssues = await res.json()
+      }
+    } catch {
+      giteaIssues = []
+    }
+  }
+
+  // 3. Process each issue
+  const items = []
+  for (const ghIssue of ghIssues) {
+    const match = isAlreadyTriaged(ghIssue, giteaIssues, { owner, repo })
+    const draft = formatGiteaDraft({ owner, repo, issue: ghIssue })
+
+    let synced = false
+    let createdIssue = null
+
+    if (!match.triaged && sync && confirm) {
+      if (giteaClient && typeof giteaClient.createIssue === 'function') {
+        createdIssue = await giteaClient.createIssue({
+          owner: giteaOwner,
+          repo: targetGiteaRepo,
+          draft,
+        })
+        synced = true
+      } else if (typeof fetchFn === 'function') {
+        try {
+          const postUrl = `${giteaBaseUrl.replace(/\/$/, '')}/api/v1/repos/${giteaOwner}/${targetGiteaRepo}/issues`
+          const headers = {
+            'content-type': 'application/json',
+            accept: 'application/json',
+          }
+          if (token) headers.authorization = `token ${token}`
+          const postRes = await fetchFn(postUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+              title: draft.title,
+              body: draft.body,
+            }),
+          })
+          if (postRes.ok) {
+            createdIssue = await postRes.json()
+            synced = true
+          }
+        } catch (err) {
+          createdIssue = { error: String((err && err.message) || err) }
+        }
+      }
+    }
+
+    items.push({
+      githubIssueNumber: ghIssue.number,
+      title: ghIssue.title,
+      htmlUrl: ghIssue.html_url,
+      state: ghIssue.state,
+      alreadyTriaged: match.triaged,
+      giteaIssueNumber: match.giteaIssueNumber || (createdIssue && createdIssue.number) || null,
+      giteaIssueUrl: match.giteaIssueUrl || (createdIssue && createdIssue.html_url) || null,
+      draft,
+      synced,
+      createdIssue,
+    })
+  }
+
+  return {
+    repository: `${owner}/${repo}`,
+    giteaRepository: `${giteaOwner}/${targetGiteaRepo}`,
+    totalExternalIssues: items.length,
+    triagedCount: items.filter((i) => i.alreadyTriaged).length,
+    pendingCount: items.filter((i) => !i.alreadyTriaged).length,
+    syncedCount: items.filter((i) => i.synced).length,
+    items,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-github-ops",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "GitHub operations for DeepSeek Harness: releases, tags, a guarded generic API pass-through, workflow runs, secrets and sanitized mirror publication.",
   "license": "MIT",
   "type": "module",