ya-git-jira 1.5.0 → 2.0.0

package/index.ts

@@ -1,4 +1,5 @@
 export * from "./lib/json.ts"
+export * from "./lib/confluence"
 export * from "./lib/git.ts"
 export * from "./lib/gitlab"
 export * from "./lib/is_main.ts"

package/lib/api.ts

@@ -0,0 +1,177 @@
+import type { JSONValue } from './json'
+import { getGitlabConfig } from './gitlab/config'
+import { getJiraConfig } from './jira'
+import { getConfluenceConfig } from './confluence/config'
+
+export interface ApiResponse {
+    status: number
+    headers: Headers
+    body: JSONValue
+}
+
+interface ServiceDef {
+    getConfig: () => Promise<{ host: string; token: string }>
+    basePath: string
+    authHeader: (token: string) => [string, string]
+}
+
+const services: Record<string, ServiceDef> = {
+    gitlab: {
+        getConfig: getGitlabConfig,
+        basePath: '/api/v4',
+        authHeader: (token) => ['Private-Token', token],
+    },
+    jira: {
+        getConfig: getJiraConfig,
+        basePath: '/rest/api/3',
+        authHeader: (token) => ['Authorization', `Basic ${token}`],
+    },
+    confluence: {
+        getConfig: getConfluenceConfig,
+        basePath: '/wiki/api/v2',
+        authHeader: (token) => ['Authorization', `Basic ${token}`],
+    },
+}
+
+export const serviceNames = Object.keys(services)
+
+export function getService(name: string): ServiceDef {
+    const svc = services[name]
+    if (!svc) {
+        throw new Error(`Unknown service: ${name}. Expected one of: ${serviceNames.join(', ')}`)
+    }
+    return svc
+}
+
+export interface RequestOptions {
+    raw?: boolean
+    data?: string
+}
+
+export async function apiRequest(
+    serviceName: string,
+    method: string,
+    endpoint: string,
+    options?: RequestOptions,
+): Promise<ApiResponse> {
+    const svc = getService(serviceName)
+    const { host, token } = await svc.getConfig()
+    const [headerName, headerValue] = svc.authHeader(token)
+
+    let path = endpoint
+    if (path.startsWith('/')) {
+        path = path.slice(1)
+    }
+
+    let url: string
+    if (options?.raw) {
+        url = `https://${host}/${path}`
+    } else {
+        url = `https://${host}${svc.basePath}/${path}`
+    }
+
+    const headers = new Headers()
+    headers.append(headerName, headerValue)
+    headers.append('Accept', 'application/json')
+
+    const fetchOptions: RequestInit = { method, headers }
+    if (options?.data) {
+        headers.append('Content-Type', 'application/json')
+        fetchOptions.body = options.data
+    }
+
+    const request = new Request(url, fetchOptions)
+    const response = await fetch(request)
+    const body = await response.json() as JSONValue
+
+    return {
+        status: response.status,
+        headers: response.headers,
+        body,
+    }
+}
+
+function getNextLink(link: string | null): string | undefined {
+    if (!link) {
+        return undefined
+    }
+    const regex = /<([^>]+)>; rel="next"/
+    const match = link.match(regex)
+    return match ? match[1] : undefined
+}
+
+export async function apiPaginate(
+    serviceName: string,
+    endpoint: string,
+    options?: RequestOptions,
+): Promise<ApiResponse> {
+    const svc = getService(serviceName)
+    const { host, token } = await svc.getConfig()
+    const [headerName, headerValue] = svc.authHeader(token)
+
+    let path = endpoint
+    if (path.startsWith('/')) {
+        path = path.slice(1)
+    }
+
+    let url: string
+    if (options?.raw) {
+        url = `https://${host}/${path}`
+    } else {
+        url = `https://${host}${svc.basePath}/${path}`
+    }
+
+    const headers = new Headers()
+    headers.append(headerName, headerValue)
+    headers.append('Accept', 'application/json')
+    const fetchOptions = { method: 'GET', headers }
+
+    const origin = `https://${host}`
+    let allResults: Array<JSONValue> = []
+    let lastStatus = 0
+    let lastHeaders: Headers = new Headers()
+
+    while (url) {
+        const request = new Request(url, fetchOptions)
+        const response = await fetch(request)
+        lastStatus = response.status
+        lastHeaders = response.headers
+
+        if (!response.ok) {
+            const body = await response.json() as JSONValue
+            return { status: response.status, headers: response.headers, body }
+        }
+
+        const body = await response.json() as JSONValue
+
+        // handle array responses (gitlab style)
+        if (Array.isArray(body)) {
+            allResults = allResults.concat(body)
+        // handle envelope responses with .results (confluence style)
+        } else if (body && typeof body === 'object' && 'results' in body) {
+            const envelope = body as { results?: Array<JSONValue>; _links?: { next?: string } }
+            if (Array.isArray(envelope.results)) {
+                allResults = allResults.concat(envelope.results)
+            }
+            // confluence v1 pagination via _links.next
+            const linksNext = envelope._links?.next
+            if (linksNext) {
+                url = linksNext.startsWith('/') ? `${origin}${linksNext}` : linksNext
+                continue
+            }
+        } else {
+            // single object response -- no pagination possible
+            return { status: response.status, headers: response.headers, body }
+        }
+
+        // standard Link header pagination
+        const nextLink = getNextLink(response.headers.get('Link'))
+        if (nextLink) {
+            url = nextLink.startsWith('/') ? `${origin}${nextLink}` : nextLink
+        } else {
+            url = ''
+        }
+    }
+
+    return { status: lastStatus, headers: lastHeaders, body: allResults }
+}

package/lib/confluence/api.ts

@@ -0,0 +1,132 @@
+import type { JSONValue } from '../json'
+import { getConfluenceConfig } from './config'
+
+function getNextLink(link: string | null): string | undefined {
+    if (!link) {
+        return undefined
+    }
+    const regex = /<([^>]+)>; rel="next"/
+    const match = link.match(regex)
+    const next = match ? match[1] : undefined
+    return next
+}
+
+export async function confluenceApi(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith('/')) {
+        console.warn(`confluenceApi: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
+    const method = 'GET'
+    const { host, token } = await getConfluenceConfig()
+    const base = `https://${host}/wiki/api/v2`
+    const uri = `${base}/${endpoint}`
+    const auth = `Basic ${token}`
+    const headers = new Headers()
+    headers.append('Authorization', auth)
+    headers.append('Accept', 'application/json')
+    const options = {
+        method,
+        headers,
+    }
+    let request = new Request(uri, options)
+    const response = await fetch(request)
+    let link = getNextLink(response.headers.get('Link'))
+    const body = await response.json() as JSONValue & { results?: Array<JSONValue> }
+    if (!body.results) {
+        return body
+    }
+    let result: Array<JSONValue> = body.results
+    const origin = `https://${host}`
+    while (link) {
+        const url = link.startsWith('/') ? `${origin}${link}` : link
+        let request = new Request(url, options)
+        const next_response = await fetch(request)
+        link = getNextLink(next_response.headers.get('Link'))
+        const next_body = await next_response.json() as JSONValue & { results?: Array<JSONValue> }
+        if (next_body.results) {
+            result = result.concat(next_body.results)
+        }
+    }
+    return result
+}
+
+export async function confluenceApiWrite(endpoint: string, method: string, body: JSONValue): Promise<JSONValue> {
+    if (endpoint.startsWith('/')) {
+        console.warn(`confluenceApiWrite: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
+    const { host, token } = await getConfluenceConfig()
+    const base = `https://${host}/wiki/api/v2`
+    const uri = `${base}/${endpoint}`
+    const auth = `Basic ${token}`
+    const headers = new Headers()
+    headers.append('Authorization', auth)
+    headers.append('Accept', 'application/json')
+    headers.append('Content-Type', 'application/json')
+    const options = {
+        method,
+        headers,
+        body: JSON.stringify(body),
+    }
+    const request = new Request(uri, options)
+    const response = await fetch(request)
+    if (!response.ok) {
+        const text = await response.text()
+        throw new Error(`Confluence API ${method} ${endpoint} failed (${response.status}): ${text}`)
+    }
+    const result = await response.json()
+    return result
+}
+
+export async function confluenceSearch(cql: string): Promise<JSONValue> {
+    const { host, token } = await getConfluenceConfig()
+    const base = `https://${host}/wiki/rest/api`
+    const auth = `Basic ${token}`
+    const headers = new Headers()
+    headers.append('Authorization', auth)
+    headers.append('Accept', 'application/json')
+    const options = { method: 'GET', headers }
+    const origin = `https://${host}`
+
+    let uri = `${base}/search?cql=${encodeURIComponent(cql)}&limit=25`
+    let allResults: Array<JSONValue> = []
+
+    while (uri) {
+        const request = new Request(uri, options)
+        const response = await fetch(request)
+        const body = await response.json() as JSONValue & {
+            results?: Array<JSONValue>
+            _links?: { next?: string }
+        }
+        if (body.results) {
+            allResults = allResults.concat(body.results)
+        }
+        const next = body._links?.next
+        uri = next ? (next.startsWith('/') ? `${origin}${next}` : next) : ''
+    }
+
+    return allResults
+}
+
+export async function confluenceApiV1(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith('/')) {
+        console.warn(`confluenceApiV1: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
+    const method = 'GET'
+    const { host, token } = await getConfluenceConfig()
+    const base = `https://${host}/wiki/rest/api`
+    const uri = `${base}/${endpoint}`
+    const auth = `Basic ${token}`
+    const headers = new Headers()
+    headers.append('Authorization', auth)
+    headers.append('Accept', 'application/json')
+    const options = {
+        method,
+        headers,
+    }
+    const request = new Request(uri, options)
+    const response = await fetch(request)
+    const result = await response.json()
+    return result
+}

package/lib/confluence/config.ts

@@ -0,0 +1,25 @@
+import { getConfig } from '../git'
+
+export interface ConfluenceConfig {
+    host: string
+    token: string
+}
+
+const gitEmailP = getConfig('user.email')
+const jiraEmailP = getConfig('jira.user')
+const confluenceEmailP = getConfig('confluence.user', { expectQuiet: true })
+const jiraHostP = getConfig('jira.host')
+const confluenceHostP = getConfig('confluence.host', { expectQuiet: true })
+const jiraTokenP = getConfig('jira.token')
+const confluenceTokenP = getConfig('confluence.token', { expectQuiet: true })
+
+export async function getConfluenceConfig(): Promise<ConfluenceConfig> {
+    const host = await confluenceHostP || await jiraHostP
+    if (!host) throw new Error('confluence.host or jira.host not in git config')
+    const user = await confluenceEmailP || await jiraEmailP || await gitEmailP
+    if (!user) throw new Error('confluence.user, jira.user, or user.email not in git config')
+    const pat = await confluenceTokenP || await jiraTokenP
+    if (!pat) throw new Error('confluence.token or jira.token not in git config')
+    const token = Buffer.from(`${user}:${pat}`).toString('base64')
+    return { host, token }
+}

package/lib/confluence/index.ts

@@ -0,0 +1,3 @@
+export * from './api'
+export * from './config'
+export * from './types'

package/lib/confluence/types.ts

@@ -0,0 +1,59 @@
+import type { JSONValue } from '../json'
+
+export type ConfluenceUser = JSONValue & {
+    type: string
+    accountId: string
+    accountType: string
+    email: string
+    publicName: string
+    displayName: string
+}
+
+export type Space = JSONValue & {
+    id: string
+    key: string
+    name: string
+    type: string
+    status: string
+}
+
+export type SearchResult = JSONValue & {
+    content: {
+        id: string
+        type: string
+        status: string
+        title: string
+    }
+    title: string
+    excerpt: string
+    url: string
+    resultGlobalContainer: {
+        title: string
+        displayUrl: string
+    }
+}
+
+export type Page = JSONValue & {
+    id: string
+    status: string
+    title: string
+    spaceId: string
+    parentId: string
+    parentType: string
+    position: number
+    version: {
+        number: number
+        message: string
+        createdAt: string
+    }
+    body?: {
+        storage?: {
+            representation: string
+            value: string
+        }
+        atlas_doc_format?: {
+            representation: string
+            value: string
+        }
+    }
+}

package/lib/git.ts

@@ -1,7 +1,7 @@
-import { doCommand } from "./spawn"
+import { doCommand, defaultOptions } from "./spawn"
 
-export async function getConfig(key: string): Promise<string> {
-    return doCommand(["git", "config", "--get", key])
+export async function getConfig(key: string, options = defaultOptions): Promise<string> {
+    return doCommand(["git", "config", "--get", key], options)
 }
 
 export async function createBranch(name: string): Promise<string> {

package/lib/gitlab/config.ts

@@ -6,15 +6,15 @@ export interface GitlabConfig {
     token: string
 }
 
+const gitEmailP = getConfig("user.email")
+const gitlabEmailP = getConfig("gitlab.user", { expectQuiet: true})
 const hostP = getConfig("gitlab.host")
-const userP = getConfig("user.email")
 const tokenP = getConfig("gitlab.token")
 
 export async function getGitlabConfig(): Promise<GitlabConfig> {
-    const host = await hostP
-    if (!host) throw new Error("gitlab.host not in git config")
-    const user = await userP
-    if (!user) throw new Error("user.email not in git config")
+    const host = await hostP || 'gitlab.com'
+    const user = await gitEmailP || await gitlabEmailP
+    if (!user) throw new Error("Neither user.email nor gitlab.email in git config")
     const token = await tokenP
     if (!token) throw new Error("gitlab.token not in git config")
     return { host, user, token }

package/lib/gitlab/index.ts

@@ -1,6 +1,7 @@
 export * from './api'
 export * from './config'
 export * from './group'
+export * from './job'
 export * from './merge-request'
 export * from './namespace'
 export * from './pipeline'

package/lib/gitlab/job.ts

@@ -0,0 +1,31 @@
+import { dlog } from "./dlog"
+import { projectScopedGet, projectScopedGetText } from "./project"
+import type { JSONValue } from "../json"
+
+export type Job = JSONValue & {
+    id: number
+    name: string
+    status: string
+    stage: string
+    ref: string
+    web_url: string
+    duration: number | null
+    finished_at: string | null
+    failure_reason: string | null
+    pipeline: { id: number }
+}
+
+export async function getPipelineJobs(pipelineId: number): Promise<Array<Job>> {
+    dlog(`getPipelineJobs pipelineId: ${pipelineId}`)
+    return await projectScopedGet(`pipelines/${pipelineId}/jobs`) as Array<Job>
+}
+
+export async function getJob(jobId: number): Promise<Job> {
+    dlog(`getJob jobId: ${jobId}`)
+    return await projectScopedGet(`jobs/${jobId}`) as Job
+}
+
+export async function getJobLog(jobId: number): Promise<string> {
+    dlog(`getJobLog jobId: ${jobId}`)
+    return await projectScopedGetText(`jobs/${jobId}/trace`)
+}

package/lib/gitlab/merge-request.ts

@@ -5,13 +5,17 @@ import { gitlabApi } from './api'
 
 export type MergeRequest = JSONValue & {
     id: number
+    iid: number
     title : string
     description : string
     state : string
+    draft: boolean
     source_branch: string
     target_branch: string
     web_url: string
     merge_status: string
+    author: { username: string }
+    labels: string[]
 }
 
 export async function getMergeRequest(id: string): Promise<MergeRequest> {
@@ -29,3 +33,19 @@ export async function getMyMergeRequestsToReview() : Promise<Array<MergeRequest>
     const me = await whoami()
     return await gitlabApi(`merge_requests?state=opened&reviewer_id=${me.id}`) as Array<MergeRequest>
 }
+
+/**
+ * List open merge requests for a specific project and source branch.
+ * @param projectPath - Full project path (e.g. "etagen-internal/eta-lib/base")
+ * @param sourceBranch - Source branch name to filter on
+ */
+export async function getMergeRequestsByBranch(
+    projectPath: string,
+    sourceBranch: string,
+): Promise<Array<MergeRequest>> {
+    const project = encodeURIComponent(projectPath)
+    const branch = encodeURIComponent(sourceBranch)
+    return await gitlabApi(
+        `projects/${project}/merge_requests?state=opened&source_branch=${branch}`
+    ) as Array<MergeRequest>
+}

package/lib/gitlab/pipeline.ts

@@ -1,6 +1,8 @@
 import { dlog } from "./dlog"
 import { projectScopedGet } from "./project"
 import { whoami } from "./user"
+import { gitlabApi } from "./api"
+import { getCurrentBranch } from "../git"
 import type { JSONValue } from "../json"
 
 export type Pipeline = JSONValue & {
@@ -12,7 +14,7 @@ export type Pipeline = JSONValue & {
     updated_at: string  // datetime string like "2021-03-18T15:00:00.000Z"
 }
 
-export type PipelineStatus = 'success' | 'running'
+export type PipelineStatus = 'success' | 'running' | 'failed' | 'canceled' | 'pending' | 'created'
 
 export interface GetPipelineOptions {
     days: number
@@ -30,3 +32,28 @@ export async function getProjectPipelines(options: GetPipelineOptions): Promise<
     dlog(`updated: ${updated}`)
     return await projectScopedGet(`pipelines?status=${status}&username=${username}&updated_after=${updated}`) as Array<Pipeline>
 }
+
+/**
+ * Get pipelines for a specific merge request.
+ * Returns pipelines sorted by ID descending (most recent first).
+ * @param projectPath - Full project path (e.g. "etagen-internal/eta-lib/base")
+ * @param mrIid - The merge request IID (project-scoped ID)
+ */
+export async function getMergeRequestPipelines(
+    projectPath: string,
+    mrIid: number,
+): Promise<Array<Pipeline>> {
+    const project = encodeURIComponent(projectPath)
+    return await gitlabApi(
+        `projects/${project}/merge_requests/${mrIid}/pipelines`
+    ) as Array<Pipeline>
+}
+
+export async function getLatestPipeline(): Promise<Pipeline | undefined> {
+    const ref = await getCurrentBranch()
+    dlog(`getLatestPipeline ref: ${ref}`)
+    const pipelines = await projectScopedGet(
+        `pipelines?ref=${encodeURIComponent(ref)}&per_page=1&order_by=id&sort=desc`
+    ) as Array<Pipeline>
+    return pipelines.length > 0 ? pipelines[0] : undefined
+}

package/lib/gitlab/project.ts

@@ -50,7 +50,7 @@ export async function findProject(ssh_url: string): Promise<Project | undefined>
     return project
 }
 
-export async function projectScopedGet(endpoint: string): Promise<JSONValue> {
+async function projectScopedRequest(endpoint: string): Promise<Response> {
     if (endpoint.startsWith("/")) {
         console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`)
         endpoint = endpoint.slice(1)
@@ -63,16 +63,25 @@ export async function projectScopedGet(endpoint: string): Promise<JSONValue> {
         throw new Error(`Could not find project for remote ${remote}`)
     }
     const base = `https://${host}/api/v4/projects/${project.id}`
-    const uri = `${base}/${endpoint}`
-    dlog(`projectScopedGet uri: ${uri}`)
+    const sep = endpoint.includes('?') ? '&' : '?'
+    const uri = `${base}/${endpoint}${sep}per_page=100`
+    dlog(`projectScopedRequest uri: ${uri}`)
     const headers = new Headers()
-    headers.append("Accept", "application/json")
     headers.append('Private-Token', token)
     const options = {
         method,
         headers,
     }
     const request = new Request(uri, options)
-    const response = await fetch(request)
+    return await fetch(request)
+}
+
+export async function projectScopedGet(endpoint: string): Promise<JSONValue> {
+    const response = await projectScopedRequest(endpoint)
     return await response.json()
 }
+
+export async function projectScopedGetText(endpoint: string): Promise<string> {
+    const response = await projectScopedRequest(endpoint)
+    return await response.text()
+}

package/lib/help.ts

@@ -0,0 +1,40 @@
+import type { Command } from 'commander'
+
+// Recursively format a Commander command tree using box-drawing characters
+export function formatCommandTree(cmd: Command): string {
+    const lines: Array<string> = []
+    const name = cmd.name() || 'gitj'
+    lines.push(name)
+    appendChildren(lines, cmd, '')
+    return lines.join('\n')
+}
+
+function appendChildren(lines: Array<string>, cmd: Command, prefix: string): void {
+    const children = cmd.commands as Array<Command>
+    if (!children || children.length === 0) return
+
+    const descWidth = longestNameChain(children)
+
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i]
+        const isLast = i === children.length - 1
+        const connector = isLast ? '└── ' : '├── '
+        const childPrefix = isLast ? '    ' : '│   '
+        const name = child.name()
+        const desc = child.description()
+        const padding = desc ? ' '.repeat(Math.max(1, descWidth - name.length + 2)) : ''
+        const descPart = desc ? padding + desc : ''
+        lines.push(`${prefix}${connector}${name}${descPart}`)
+        appendChildren(lines, child, prefix + childPrefix)
+    }
+}
+
+// Find the longest command name among siblings for alignment
+function longestNameChain(commands: Array<Command>): number {
+    let max = 0
+    for (const cmd of commands) {
+        const len = cmd.name().length
+        if (len > max) max = len
+    }
+    return max
+}

package/lib/jira.ts

@@ -14,13 +14,18 @@ export interface JiraConfig {
     token: string
 }
 
+const gitEmailP = getConfig("user.email")
+const jiraEmailP = getConfig("jira.user")
+const hostP = getConfig("jira.host")
+const tokenP = getConfig("jira.token")
+
 export async function getJiraConfig(): Promise<JiraConfig> {
-    const host = await getConfig("jira.host")
+    const host = await hostP
     if (!host) throw new Error("jira.host not in git config")
-    const user = await getConfig("jira.user") || await getConfig("user.email")
+    const user = await jiraEmailP || await gitEmailP
     if (!user) throw new Error("jira.user or user.email not in git config")
-    const pat = await getConfig("jira.pat")
-    if (!pat) throw new Error("jira.pat not in git config")
+    const pat = await tokenP
+    if (!pat) throw new Error("jira.token not in git config")
     const token = Buffer.from(`${user}:${pat}`).toString('base64')
     return { host, token }
 }
@@ -57,7 +62,7 @@ type Myself = JSONValue & {
 }
 
 export async function getMyself(): Promise<Myself> {
-    return await jiraApi("/myself") as Myself
+    return await jiraApi("myself") as Myself
 }
 
 type SearchResponse = JSONValue & {
@@ -68,6 +73,6 @@ export async function myUnresolvedIssues(): Promise<Array<Issue>> {
     const myself = await getMyself()
     const myselfId = myself.accountId
     const jql = `assignee = ${myselfId} AND resolution = Unresolved`
-    const issues = await jiraApi(`/search?jql=${encodeURIComponent(jql)}`) as SearchResponse
+    const issues = await jiraApi(`search/jql?jql=${encodeURIComponent(jql)}&fields=summary`) as SearchResponse
     return issues.issues
 }