@goodandready/dsh-github-ops 0.4.1 → 0.6.0

package/lib/routes.js

@@ -5,16 +5,18 @@
 // 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, parseDiffHunks, parseGitGraph } from './scm.js'
+import { SseEventManager } from './events.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 +30,15 @@ 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'
+
+/** Where Git commit graph is read. */
+export const GRAPH_PATH = '/dsh-github-ops/graph'
+
+/** Where real-time CI and PR events are streamed via SSE. */
+export const EVENTS_PATH = '/dsh-github-ops/events'
+
 /**
  * Register the three routes.
  *
@@ -157,9 +168,22 @@ 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 })
+              const answer = await git(argv, { cwd, timeoutMs: 120000, input: built.input })
               steps.push({
                 argv,
                 code: answer.code,
@@ -178,7 +202,29 @@ 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
+            }
+            const hunks = diff.code === 0 ? parseDiffHunks(text) : []
+            return sendJson(res, 200, {
+              file,
+              staged,
+              diff: String(text || '').slice(0, 200000),
+              hunks,
+              hasConflicts: hasConflictsFlag,
+              conflicts,
+            })
           }
 
           const stash = url.searchParams.get('stash') || ''
@@ -280,6 +326,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 +363,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 +443,91 @@ 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()
+
+      const registerGraph = () => wctx.webServer.register({
+        kind: 'exact',
+        path: GRAPH_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 git = makeGitRunner()
+            const url = new URL(req.url || '/', 'http://localhost')
+            const requested = validateCwd(url.searchParams.get('cwd') || '')
+            let cwd = safeCwd(ctx)
+            if (requested) {
+              if (!existsSync(requested) || !statSync(requested).isDirectory()) {
+                return sendJson(res, 400, { error: `not a directory: ${requested}` })
+              }
+              cwd = requested
+            }
+            const limitParam = parseInt(url.searchParams.get('limit') || '15', 10)
+            const limit = Math.max(1, Math.min(Number.isFinite(limitParam) ? limitParam : 15, 50))
+            const answer = await git(['log', `-n`, String(limit), '--graph', '--date=short', '--format=format:%h|%d|%s|%an|%cd'], { cwd })
+            if (answer.code !== 0) {
+              return sendJson(res, 200, { ok: false, error: answer.stderr || 'git log failed', entries: [] })
+            }
+            const entries = parseGitGraph(answer.stdout)
+            return sendJson(res, 200, { ok: true, limit, entries, raw: answer.stdout })
+          } catch (err) {
+            return sendJson(res, 500, { ok: false, error: describeError(err) })
+          }
+        },
+      })
+      if (typeof wctx.effect === 'function') wctx.effect(registerGraph, 'dsh-github-ops: graph route')
+      else registerGraph()
+
+      const eventManager = new SseEventManager({
+        client,
+        liveConfig,
+        describeError,
+      })
+      if (typeof wctx.effect === 'function') {
+        wctx.effect(() => () => eventManager.destroy(), 'dsh-github-ops: events teardown')
+      }
+
+      const registerEvents = () => wctx.webServer.register({
+        kind: 'exact',
+        path: EVENTS_PATH,
+        handler: async (req, res) => {
+          if (req.method !== 'GET') return sendJson(res, 405, { error: 'method not allowed' })
+          if (!isTrustedRequest(req)) return sendJson(res, 403, { error: 'forbidden' })
+          res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+          })
+          if (typeof res.flushHeaders === 'function') res.flushHeaders()
+          eventManager.addClient(res, req)
+        },
+      })
+      if (typeof wctx.effect === 'function') wctx.effect(registerEvents, 'dsh-github-ops: events route')
+      else registerEvents()
+
     } catch (err) {
       ctx.logger?.warn?.('[dsh-github-ops] panel route not registered:', err && err.message)
     }
@@ -401,7 +539,7 @@ export function registerRoutes(ctx, deps = {}) {
  * Read a small JSON body, bounded, so a POST that names an action cannot exhaust memory.
  * The panel sends a few hundred bytes; anything larger is refused rather than buffered.
  */
-function readJsonBody(req, limit = 64 * 1024) {
+function readJsonBody(req, limit = 512 * 1024) {
   return new Promise((resolve, reject) => {
     let size = 0
     const chunks = []

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
@@ -44,6 +46,19 @@ export function validateStashRef(ref) {
   return value
 }
 
+
+export function validatePatch(patch) {
+  const value = String(patch == null ? '' : patch)
+  if (value.includes('\u0000')) throw new Error('refusing a patch with a NUL byte')
+  const trimmed = value.trim()
+  if (!trimmed) throw new Error('a patch cannot be empty')
+  if (trimmed.length > 500000) throw new Error('refusing a patch longer than 500000 characters')
+  if (!trimmed.includes('@@') && !trimmed.includes('---')) {
+    throw new Error('refusing an invalid patch format: missing diff hunk markers')
+  }
+  return value
+}
+
 const CONTINUE_VERBS = ['merge', 'rebase', 'cherry-pick', 'revert']
 
 /**
@@ -113,6 +128,28 @@ export function buildAction(action, args = {}) {
       const verb = String(args.verb || '').trim()
       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 'stagePatch':
+    case 'stage_patch': {
+      const patch = validatePatch(args.patch)
+      const res = result('stage_patch', [['apply', '--cached', '-']], false, 'stage patch hunk')
+      res.input = patch
+      return res
+    }
+    case 'unstagePatch':
+    case 'unstage_patch': {
+      const patch = validatePatch(args.patch)
+      const res = result('unstage_patch', [['apply', '--cached', '--reverse', '-']], false, 'unstage patch hunk')
+      res.input = patch
+      return res
+    }
+    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)
@@ -156,6 +193,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 +231,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,293 @@ 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)
+}
+
+/**
+ * Splits a unified diff into individual hunks with their headers and ready-to-apply patches.
+ */
+export function parseDiffHunks(diffText) {
+  if (typeof diffText !== 'string' || !diffText.trim()) return []
+  const lines = diffText.split('\n')
+  const fileHeaderLines = []
+  let i = 0
+  while (i < lines.length && !lines[i].startsWith('@@')) {
+    fileHeaderLines.push(lines[i])
+    i++
+  }
+  const fileHeader = fileHeaderLines.length > 0 ? fileHeaderLines.join('\n') + '\n' : ''
+
+  const hunks = []
+  let currentHunk = null
+
+  while (i < lines.length) {
+    const line = lines[i]
+    if (line.startsWith('@@')) {
+      if (currentHunk) {
+        currentHunk.patch = fileHeader + currentHunk.lines.map((l) => l.raw).join('\n') + '\n'
+        hunks.push(currentHunk)
+      }
+      const match = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/)
+      currentHunk = {
+        header: line,
+        oldStart: match ? parseInt(match[1], 10) : 0,
+        oldCount: match ? (match[2] !== undefined ? parseInt(match[2], 10) : 1) : 0,
+        newStart: match ? parseInt(match[3], 10) : 0,
+        newCount: match ? (match[4] !== undefined ? parseInt(match[4], 10) : 1) : 0,
+        heading: match ? match[5].trim() : '',
+        lines: [{ type: 'hunk_header', text: line, raw: line }],
+        patch: '',
+      }
+    } else if (currentHunk) {
+      let type = 'context'
+      if (line.startsWith('+')) type = 'add'
+      else if (line.startsWith('-')) type = 'del'
+      else if (line.startsWith('\\')) type = 'meta'
+      currentHunk.lines.push({ type, text: line, raw: line })
+    }
+    i++
+  }
+
+  if (currentHunk) {
+    currentHunk.patch = fileHeader + currentHunk.lines.map((l) => l.raw).join('\n') + '\n'
+    hunks.push(currentHunk)
+  }
+
+  return hunks
+}
+
+/**
+ * Parses git log --graph --date=short --format=format:'%h|%d|%s|%an|%cd' output.
+ */
+export function parseGitGraph(text) {
+  if (typeof text !== 'string' || !text.trim()) return []
+  const lines = text.split('\n')
+  const results = []
+
+  for (const rawLine of lines) {
+    if (!rawLine.trim()) continue
+    const match = rawLine.match(/^([*|/\\_\-\s]*?)\s*([0-9a-f]{7,40})\|([^|]*)\|([^|]*)\|([^|]*)\|(.*)$/)
+    if (match) {
+      const graph = match[1] || '*'
+      const hash = match[2]
+      const rawRefs = match[3].trim()
+      const subject = match[4].trim()
+      const author = match[5].trim()
+      const date = match[6].trim()
+
+      let refs = []
+      if (rawRefs) {
+        const cleanRefs = rawRefs.replace(/^\(|\)$/g, '').trim()
+        if (cleanRefs) {
+          refs = cleanRefs.split(',').map((r) => r.trim()).filter(Boolean)
+        }
+      }
+      results.push({
+        isCommit: true,
+        graph,
+        hash,
+        refs,
+        subject,
+        author,
+        date,
+        raw: rawLine,
+      })
+    } else {
+      results.push({
+        isCommit: false,
+        graph: rawLine,
+        hash: '',
+        refs: [],
+        subject: '',
+        author: '',
+        date: '',
+        raw: rawLine,
+      })
+    }
+  }
+
+  return results
+}