dsh-github-router 0.1.0

package/lib/core/file.js

@@ -0,0 +1,166 @@
+/**
+ * File aggregation: api contents (base64) → raw.githubusercontent.com
+ * (direct/proxy) → user-configured mirrors → git protocol (local repo or
+ * the plugin fetch cache). Read-only by construction.
+ * @module dsh-github-router/core/file
+ */
+import { effectiveProxy } from '../config.js'
+import { fetchText } from '../net.js'
+import { GitFetchCache, findLocalRepo, gitVersion, readCacheFile, readLocalFile } from '../routes/git.js'
+import { fetchViaMirrors } from '../routes/mirror.js'
+import { guardByteCount, guardFilePath, guardOwnerRepo, guardRef } from '../util.js'
+import { attemptLadder, buildRuntime } from './runtime.js'
+
+const SHA_RE = /^[0-9a-f]{40}$/i
+
+function decodeBase64(content) {
+  try {
+    return Buffer.from(content, 'base64').toString('utf8')
+  } catch {
+    return String(content ?? '')
+  }
+}
+
+export async function aggregateFile(ctx, options, args) {
+  const owner = guardOwnerRepo(args.owner, 'owner')
+  const repo = guardOwnerRepo(args.repo, 'repo')
+  const path = guardFilePath(args.path)
+  const ref = args.ref === undefined || args.ref === null || String(args.ref).trim() === '' ? 'HEAD' : guardRef(args.ref, 'ref')
+  const maxBytes = guardByteCount(args.maxBytes, 'maxBytes', 262144, 4096, options.maxBytes)
+  const { cwd, signal } = args
+
+  const runtime = buildRuntime(ctx, options)
+  const { subprocess, fetchImpl, cache, api } = runtime
+  const token = await runtime.resolveToken()
+  const notes = []
+  const failures = []
+  let result = null
+
+  // ------------------------------------------------------------ 1) api route
+  if (options.routes.api) {
+    try {
+      const attempt = await attemptLadder(
+        (proxy) =>
+          api.getJson(`/repos/${owner}/${repo}/contents/${path}`, {
+            token,
+            signal,
+            proxy,
+            cache,
+            ttlMs: options.cacheTtlSeconds.content,
+            forceRefresh: args.forceRefresh === true,
+            fetchImpl,
+            query: { ref },
+          }),
+        options,
+      )
+      const value = attempt.value
+      if (Array.isArray(value)) {
+        return {
+          kind: 'directory',
+          path,
+          ref,
+          entries: value.slice(0, 200).map((e) => ({ name: e.name ?? null, type: e.type ?? null, size: e.size ?? null })),
+          route: 'api',
+          notes,
+        }
+      }
+      if (value && typeof value === 'object' && typeof value.content === 'string') {
+        const size = value.size ?? Buffer.from(value.content, 'base64').length
+        if (size <= maxBytes) {
+          result = { kind: 'file', path, ref: value.sha ?? ref, content: decodeBase64(value.content), size, truncated: false, route: 'api', notes }
+        } else {
+          notes.push(`api contents: file is ${size} bytes (cap ${maxBytes}); falling through to raw/git routes`)
+        }
+      }
+    } catch (error) {
+      failures.push(`api: ${String(error && error.message ? error.message : error).slice(0, 200)}`)
+    }
+  }
+
+  // ------------------------------------------------------- 2) raw/mirror routes
+  if (result === null) {
+    const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path}`
+    try {
+      const attempt = await attemptLadder(
+        (proxy) =>
+          fetchText(rawUrl, {
+            headers: { accept: 'text/plain', 'user-agent': 'dsh-github-router/0.1.0' },
+            timeoutMs: proxy !== undefined ? options.proxyTimeoutMs : options.directTimeoutMs,
+            proxy,
+            signal,
+            maxBytes,
+            retries: 0,
+          }),
+        options,
+      )
+      if (attempt.value.ok) {
+        result = { kind: 'file', path, ref, content: attempt.value.text, size: attempt.value.body.length, truncated: attempt.value.truncated, route: attempt.via === 'proxy' ? 'raw-proxy' : 'raw', notes }
+      } else {
+        failures.push(`raw: HTTP ${attempt.value.status}`)
+      }
+    } catch (error) {
+      failures.push(`raw: ${String(error && error.message ? error.message : error).slice(0, 200)}`)
+    }
+  }
+
+  if (result === null && options.routes.mirror && options.mirrors.length > 0) {
+    try {
+      const via = await fetchViaMirrors(owner, repo, ref, path, options.mirrors, {
+        timeoutMs: options.directTimeoutMs,
+        signal,
+        maxBytes,
+      })
+      result = { kind: 'file', path, ref, content: via.content, size: via.size, truncated: via.truncated, route: 'mirror', notes }
+    } catch (error) {
+      failures.push(`mirror: ${String(error && error.message ? error.message : error).slice(0, 200)}`)
+    }
+  }
+
+  // ------------------------------------------------------------ 3) git route
+  if (result === null && options.routes.git && subprocess !== undefined) {
+    let gitUsable = false
+    try {
+      gitUsable = await gitVersion(subprocess, signal)
+    } catch { gitUsable = false }
+    if (gitUsable) {
+      try {
+        const local = await findLocalRepo(subprocess, cwd, owner, repo, options.repos, args.localRepo)
+        if (local !== null) {
+          const read = await readLocalFile(subprocess, local, ref, path, { signal, maxStdout: maxBytes })
+          result = { kind: 'file', path, ref, content: read.content, size: Buffer.byteLength(read.content, 'utf8'), truncated: read.truncated, route: 'git-local', notes }
+        } else {
+          const cacheRepo = new GitFetchCache(subprocess, options.gitCacheDir)
+          const proxy = effectiveProxy(options)
+          let targetRef
+          let dir
+          if (SHA_RE.test(ref)) {
+            dir = (await cacheRepo.fetchSha(owner, repo, ref, { proxy, signal })).dir
+            targetRef = ref
+          } else if (ref === 'HEAD') {
+            dir = (await cacheRepo.fetchHead(owner, repo, { proxy, signal })).dir
+            targetRef = 'FETCH_HEAD'
+          } else {
+            dir = (await cacheRepo.fetchRef(owner, repo, ref, { proxy, signal })).dir
+            targetRef = `refs/gh-router/${ref}`
+          }
+          const read = await readCacheFile(subprocess, dir, targetRef, path, { signal, maxStdout: maxBytes })
+          result = { kind: 'file', path, ref, content: read.content, size: Buffer.byteLength(read.content, 'utf8'), truncated: read.truncated, route: 'git-cache', notes }
+        }
+      } catch (error) {
+        failures.push(`git: ${String(error && error.message ? error.message : error).slice(0, 200)}`)
+      }
+    } else {
+      failures.push('git: git not available')
+    }
+  }
+
+  if (result === null) {
+    return {
+      error: `all routes failed to load ${owner}/${repo} @ ${ref}: ${path}`,
+      failures,
+      notes,
+    }
+  }
+  result.failures = failures
+  return result
+}

package/lib/core/issue.js

@@ -0,0 +1,202 @@
+/**
+ * Issue aggregation: api.github.com → gh CLI → page HTML, with per-part
+ * route attribution and structured failure.
+ * @module dsh-github-router/core/issue
+ */
+import { ghAuthed, ghIssueView, ghVersion } from '../routes/gh.js'
+import { fetchAndParsePage } from '../routes/html.js'
+import { guardByteCount, guardOwnerRepo, guardPrNumber, truncateText } from '../util.js'
+import { attemptLadder, buildRuntime, rateNote } from './runtime.js'
+
+const BODY_CAP = 20000
+
+function shapeApiIssue(meta, owner, repo, number) {
+  return {
+    owner,
+    repo,
+    number,
+    title: meta.title ?? null,
+    body: truncateText(meta.body ?? '', BODY_CAP).text,
+    state: meta.state ?? null,
+    stateReason: meta.state_reason ?? null,
+    author: meta.user && meta.user.login ? meta.user.login : null,
+    createdAt: meta.created_at ?? null,
+    updatedAt: meta.updated_at ?? null,
+    closedAt: meta.closed_at ?? null,
+    commentsCount: meta.comments ?? null,
+    labels: Array.isArray(meta.labels) ? meta.labels.map((l) => l.name ?? null).filter((n) => n !== null) : [],
+    url: meta.html_url ?? null,
+  }
+}
+
+function shapeGhIssue(json, owner, repo, number) {
+  return {
+    owner,
+    repo,
+    number,
+    title: json.title ?? null,
+    body: truncateText(json.body ?? '', BODY_CAP).text,
+    state: json.state ?? null,
+    stateReason: json.stateReason ?? null,
+    author: json.author && json.author.login ? json.author.login : null,
+    createdAt: json.createdAt ?? null,
+    updatedAt: json.updatedAt ?? null,
+    closedAt: json.closedAt ?? null,
+    commentsCount: Array.isArray(json.comments) ? json.comments.length : null,
+    labels: Array.isArray(json.labels) ? json.labels.map((l) => (typeof l === 'string' ? l : l.name ?? null)).filter((n) => n !== null) : [],
+    url: null,
+  }
+}
+
+function capItems(items, maxItems, notes, label) {
+  if (items.length <= maxItems) return items
+  notes.push(`${label}: showing ${maxItems} of ${items.length}`)
+  return items.slice(0, maxItems)
+}
+
+export async function aggregateIssue(ctx, options, args) {
+  const owner = guardOwnerRepo(args.owner, 'owner')
+  const repo = guardOwnerRepo(args.repo, 'repo')
+  const number = guardPrNumber(args.number, 'number')
+  const maxComments = guardByteCount(args.maxComments, 'maxComments', 50, 5, 200)
+  const forceRefresh = args.forceRefresh === true
+  const { signal } = args
+
+  const runtime = buildRuntime(ctx, options)
+  const { subprocess, fetchImpl, cache, api } = runtime
+  const token = await runtime.resolveToken()
+  const state = {
+    issue: null,
+    comments: [],
+    routes: { meta: null, comments: null },
+    notes: [],
+  }
+
+  if (options.routes.api) {
+    try {
+      const attempt = await attemptLadder(
+        (proxy) =>
+          api.getJson(`/repos/${owner}/${repo}/issues/${number}`, {
+            token,
+            signal,
+            proxy,
+            cache,
+            ttlMs: options.cacheTtlSeconds.meta,
+            forceRefresh,
+            fetchImpl,
+          }),
+        options,
+      )
+      state.issue = shapeApiIssue(attempt.value, owner, repo, number)
+      state.routes.meta = 'api'
+      rateNote(attempt.value._headers, state.notes)
+    } catch (error) {
+      state.notes.push(`api issue: ${String(error && error.message ? error.message : error).slice(0, 220)}`)
+    }
+  }
+
+  if (state.issue !== null) {
+    try {
+      const attempt = await attemptLadder(
+        (proxy) =>
+          api.getJson(`/repos/${owner}/${repo}/issues/${number}/comments`, {
+            token,
+            signal,
+            proxy,
+            cache,
+            ttlMs: options.cacheTtlSeconds.meta,
+            forceRefresh,
+            fetchImpl,
+            query: { per_page: 100 },
+          }),
+        options,
+      )
+      state.comments = capItems(
+        (Array.isArray(attempt.value) ? attempt.value : []).map((c) => ({
+          kind: 'comment',
+          author: c.user && c.user.login ? c.user.login : null,
+          createdAt: c.created_at ?? null,
+          body: truncateText(c.body ?? '', BODY_CAP).text,
+          url: c.html_url ?? null,
+        })),
+        maxComments,
+        state.notes,
+        'comments',
+      )
+      state.routes.comments = 'api'
+    } catch (error) {
+      state.notes.push(`api comments: ${String(error && error.message ? error.message : error).slice(0, 180)}`)
+    }
+  }
+
+  if (options.routes.gh && subprocess !== undefined && (state.issue === null || state.comments.length === 0)) {
+    let ghUsable = false
+    try {
+      ghUsable = (await ghVersion(subprocess, signal)) && (await ghAuthed(subprocess, signal))
+    } catch { ghUsable = false }
+    if (ghUsable) {
+      try {
+        const g = await ghIssueView(subprocess, owner, repo, number, { signal })
+        if (state.issue === null) {
+          state.issue = shapeGhIssue(g, owner, repo, number)
+          state.routes.meta = 'gh'
+        }
+        if (state.comments.length === 0 && Array.isArray(g.comments)) {
+          state.comments = capItems(
+            g.comments.map((c) => ({
+              kind: 'comment',
+              author: c.author && c.author.login ? c.author.login : null,
+              createdAt: c.createdAt ?? null,
+              body: truncateText(c.body ?? '', BODY_CAP).text,
+              url: c.url ?? null,
+            })),
+            maxComments,
+            state.notes,
+            'comments',
+          )
+          state.routes.comments = 'gh'
+        }
+      } catch (error) {
+        state.notes.push(`gh issue view: ${String(error && error.message ? error.message : error).slice(0, 180)}`)
+      }
+    } else {
+      state.notes.push('gh route skipped: gh CLI not installed or not authenticated')
+    }
+  }
+
+  if (options.routes.html && (state.issue === null || state.comments.length === 0)) {
+    try {
+      await attemptLadder(
+        async (proxy) => {
+          const parsed = await fetchAndParsePage(owner, repo, number, 'issues', {
+            fetchImpl,
+            proxy,
+            signal,
+            timeoutMs: proxy !== undefined ? options.proxyTimeoutMs : options.directTimeoutMs,
+          })
+          if (state.issue === null && parsed.issue !== null) {
+            state.issue = { ...parsed.issue, owner, repo, number }
+            state.routes.meta = 'html'
+          }
+          if (state.comments.length === 0 && parsed.discussion.length > 0) {
+            state.comments = capItems(parsed.discussion, maxComments, state.notes, 'comments')
+            state.routes.comments = 'html'
+          }
+        },
+        options,
+        { proxyFirst: true },
+      )
+    } catch (error) {
+      state.notes.push(`html page: ${String(error && error.message ? error.message : error).slice(0, 220)}`)
+    }
+  }
+
+  if (state.issue === null) {
+    return {
+      error: `all GitHub routes failed to load issue ${owner}/${repo}#${number}`,
+      routes: state.routes,
+      notes: state.notes,
+    }
+  }
+  return { issue: state.issue, comments: state.comments, routes: state.routes, notes: state.notes }
+}