@goodandready/dsh-github-ops 0.4.1 → 0.6.0

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.6.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",