ya-git-jira 1.5.0 → 2.0.0

package/bin/git-api.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import { apiRequest, apiPaginate, serviceNames } from '../lib/api.ts'
+
+const version = await getPackageVersion()
+
+const httpMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('api')
+        .description('make an authenticated API request')
+        .argument('<service>', `service name (${serviceNames.join(', ')})`)
+        .argument('<endpoint>', 'API endpoint path (e.g. /user, /myself)')
+        .option('-X, --method <method>', 'HTTP method (default: GET, auto-promotes to POST with --data)')
+        .option('-d, --data <json>', 'request body as JSON string')
+        .option('--raw', 'don\'t prepend the default base path')
+        .option('--paginate', 'follow pagination links and return all results')
+        .option('-v, --verbose', 'show response status and headers on stderr')
+        .action(async (service: string, endpoint: string, options) => {
+            let method = options.method?.toUpperCase() ?? (options.data ? 'POST' : 'GET')
+            if (!httpMethods.includes(method)) {
+                console.error(`Unknown HTTP method: ${method}`)
+                process.exit(1)
+            }
+
+            if (options.paginate && method !== 'GET') {
+                console.error('--paginate only works with GET requests')
+                process.exit(1)
+            }
+
+            const requestOptions = {
+                raw: options.raw,
+                data: options.data,
+            }
+
+            let result
+            if (options.paginate) {
+                result = await apiPaginate(service, endpoint, requestOptions)
+            } else {
+                result = await apiRequest(service, method, endpoint, requestOptions)
+            }
+
+            if (options.verbose) {
+                console.error(`HTTP ${result.status}`)
+                result.headers.forEach((value, key) => {
+                    console.error(`${key}: ${value}`)
+                })
+                console.error('')
+            }
+
+            console.log(JSON.stringify(result.body, null, 2))
+
+            if (result.status >= 400) {
+                process.exit(1)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-api')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-page-search.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { confluenceApi, confluenceSearch } from '../lib/confluence'
+import { getConfluenceConfig } from '../lib/confluence'
+import type { Page, SearchResult } from '../lib/confluence'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('search')
+        .description('Search for Confluence pages by title (fuzzy by default)')
+        .argument('query', 'Search query')
+        .option('-v, --verbose', 'Verbose output')
+        .option('--exact', 'Exact title match (uses v2 API)')
+        .option('--full-text', 'Search page body content in addition to title')
+        .action(async (query: string, options) => {
+            const { host } = await getConfluenceConfig()
+
+            if (options.exact) {
+                const pages = await confluenceApi(`pages?title=${encodeURIComponent(query)}`) as Array<Page>
+                if (options.verbose) {
+                    console.log(pages)
+                } else {
+                    for (const page of pages) {
+                        const url = `https://${host}/wiki/spaces/${page.spaceId}/pages/${page.id}`
+                        console.log(`${page.id}\t${page.title}\t${url}`)
+                    }
+                }
+                return
+            }
+
+            const field = options.fullText ? 'text' : 'title'
+            const cql = `type=page AND ${field} ~ "${query}"`
+            const results = await confluenceSearch(cql) as Array<SearchResult>
+            if (options.verbose) {
+                console.log(results)
+            } else {
+                for (const result of results) {
+                    const id = result.content.id
+                    const title = result.content.title
+                    const url = `https://${host}${result.url}`
+                    console.log(`${id}\t${title}\t${url}`)
+                }
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-page-search')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-page-show.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { confluenceApi } from '../lib/confluence'
+import { getConfluenceConfig } from '../lib/confluence'
+import type { Page } from '../lib/confluence'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('show')
+        .description('Show information about a Confluence page')
+        .argument('id', 'Page ID')
+        .option('-v, --verbose', 'Verbose output')
+        .option('-b, --body-format <format>', 'Include page body (storage or atlas_doc_format)')
+        .option('--body-only', 'Output only the body content value (requires --body-format)')
+        .action(async (id: string, options) => {
+            let endpoint = `pages/${id}`
+            if (options.bodyFormat) {
+                endpoint += `?body-format=${options.bodyFormat}`
+            }
+            const page = await confluenceApi(endpoint) as Page
+            if (options.bodyOnly) {
+                if (!options.bodyFormat) {
+                    console.error('--body-only requires --body-format')
+                    process.exit(1)
+                }
+                const body = page.body
+                const content = options.bodyFormat === 'storage'
+                    ? body?.storage?.value
+                    : body?.atlas_doc_format?.value
+                if (content) {
+                    console.log(content)
+                } else {
+                    console.error('No body content returned')
+                    process.exit(1)
+                }
+            } else if (options.verbose) {
+                console.log(page)
+            } else {
+                const { host } = await getConfluenceConfig()
+                const url = `https://${host}/wiki/spaces/${page.spaceId}/pages/${page.id}`
+                const result: Record<string, unknown> = { id: page.id, title: page.title, spaceId: page.spaceId, url }
+                if (page.body?.storage?.value) {
+                    result.bodyLength = page.body.storage.value.length
+                }
+                console.log(result)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-page-show')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-page-update.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { confluenceApi, confluenceApiWrite } from '../lib/confluence'
+import type { Page } from '../lib/confluence'
+import type { JSONValue } from '../lib/json'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+async function readStdin(): Promise<string> {
+    const chunks: Buffer[] = []
+    for await (const chunk of Bun.stdin.stream()) {
+        chunks.push(Buffer.from(chunk))
+    }
+    return Buffer.concat(chunks).toString('utf-8')
+}
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('update')
+        .description('Update a Confluence page')
+        .argument('id', 'Page ID')
+        .option('-t, --title <title>', 'New page title (defaults to current title)')
+        .option('-f, --file <path>', 'Read body content from file (default: stdin)')
+        .option('-m, --message <message>', 'Version message')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (id: string, options) => {
+            const current = await confluenceApi(`pages/${id}`) as Page
+
+            let content: string
+            if (options.file) {
+                const file = Bun.file(options.file)
+                content = await file.text()
+            } else {
+                content = await readStdin()
+            }
+
+            if (!content.trim()) {
+                console.error('No content provided. Pipe content via stdin or use --file.')
+                process.exit(1)
+            }
+
+            const title = options.title || current.title
+            const nextVersion = current.version.number + 1
+
+            const body: JSONValue = {
+                id,
+                status: 'current',
+                title,
+                body: {
+                    representation: 'storage',
+                    value: content,
+                },
+                version: {
+                    number: nextVersion,
+                    message: options.message || '',
+                },
+            }
+
+            const result = await confluenceApiWrite(`pages/${id}`, 'PUT', body) as Page
+            if (options.verbose) {
+                console.log(result)
+            } else {
+                console.log(`Updated page ${result.id} "${result.title}" to version ${result.version.number}`)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-page-update')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-page.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import search from './git-confluence-page-search'
+import show from './git-confluence-page-show'
+import update from './git-confluence-page-update'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('page')
+        .description('Commands for working with Confluence pages')
+        .addCommand(search())
+        .addCommand(show())
+        .addCommand(update())
+        .action(() => program.help())
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-page')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-space-list.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { confluenceApi } from '../lib/confluence'
+import type { Space } from '../lib/confluence'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('list')
+        .description('List Confluence spaces')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const spaces = await confluenceApi('spaces') as Array<Space>
+            if (options.verbose) {
+                console.log(spaces)
+            } else {
+                for (const space of spaces) {
+                    console.log(`${space.key}\t${space.name}`)
+                }
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-space-list')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-space.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import list from './git-confluence-space-list'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('space')
+        .description('Commands for working with Confluence spaces')
+        .addCommand(list())
+        .action(() => program.help())
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-space')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence-whoami.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { confluenceApiV1 } from '../lib/confluence'
+import type { ConfluenceUser } from '../lib/confluence'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('whoami')
+        .description('Show the current Confluence user')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const myself = await confluenceApiV1('user/current') as ConfluenceUser
+            if (options.verbose) {
+                console.log(myself)
+            } else {
+                const { displayName, email, accountId } = myself
+                console.log({ displayName, email, accountId })
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence-whoami')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-confluence.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import whoami from './git-confluence-whoami'
+import space from './git-confluence-space'
+import page from './git-confluence-page'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('confluence')
+        .description('Commands for working with Confluence')
+        .addCommand(whoami())
+        .addCommand(space())
+        .addCommand(page())
+    return program
+}
+
+export default create
+
+if (isMain('git-confluence')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-jira-start.ts

@@ -8,7 +8,7 @@ import { isMain } from '../lib/is_main'
 const version = await getPackageVersion()
 
 function toKebab(s: string): string {
-    return s.replace(/([a-z]+)([A-Z]+)/g, "$1_2").toLowerCase()
+    return s.replace(/([a-z]+)([A-Z]+)/g, "$1_$2").toLowerCase()
         .replace(/(\W+)/g, "-")
         .replace(/-$/, "")
 }

package/bin/git-jira-whoami.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getMyself } from '../lib/jira'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('whoami')
+        .description('Show the current Jira user')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const myself = await getMyself()
+            if (options.verbose) {
+                console.log(myself)
+            } else {
+                const { displayName, emailAddress, accountId } = myself as any
+                console.log({ displayName, emailAddress, accountId })
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-jira-whoami')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-jira.ts

@@ -6,6 +6,7 @@ import { isMain } from '../lib/is_main'
 import start from './git-jira-start'
 import issue from './git-jira-issue'
 import issues from './git-jira-issue-list'
+import whoami from './git-jira-whoami'
 const version = await getPackageVersion()
 
 export function create(): Command {
@@ -17,6 +18,7 @@ export function create(): Command {
         .addCommand(start())
         .addCommand(issue())
         .addCommand(issues())
+        .addCommand(whoami())
     return program
 }
 

package/bin/git-lab-project-mr-list.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getMergeRequestsByBranch, type MergeRequest } from "../lib/gitlab"
+import { findProject } from '../lib/gitlab/project'
+import { getRemote, getCurrentBranch } from '../lib/git'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('list')
+        .description('List open merge requests for a project and branch')
+        .option('-v, --verbose', 'Verbose output')
+        .option('-p, --project <path>', 'Project path (e.g. etagen-internal/eta-lib/base). Defaults to current directory remote.')
+        .option('-b, --branch <branch>', 'Source branch to filter on. Defaults to current branch.')
+        .action(async (options) => {
+            let projectPath = options.project
+            if (!projectPath) {
+                const remote = await getRemote()
+                const project = await findProject(remote)
+                if (!project) {
+                    console.error(`Could not resolve project from remote: ${remote}`)
+                    process.exit(1)
+                }
+                projectPath = project.path_with_namespace
+            }
+
+            const branch = options.branch || await getCurrentBranch()
+
+            const mrs: Array<MergeRequest> = await getMergeRequestsByBranch(projectPath, branch)
+            if (!mrs.length) {
+                console.error(`No open MRs for branch '${branch}' in ${projectPath}`)
+                process.exit(0)
+            }
+            if (options.verbose) {
+                console.log(mrs)
+            }
+            else {
+                const filtered = mrs.map(m => {
+                    const { iid, title, web_url, source_branch, target_branch, state, draft } = m
+                    return { iid, title, web_url, source_branch, target_branch, state, draft }
+                })
+                console.log(filtered)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-mr-list')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-project-mr.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import list from './git-lab-project-mr-list'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('mr')
+        .description('Commands for working with merge requests')
+        .addCommand(list())
+        .action(() => program.help())
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-mr')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-project-pipeline-jobs.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getPipelineJobs, type Job } from '../lib/gitlab'
+import { isMain } from '../lib/is_main'
+
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('jobs')
+        .description('List jobs for a pipeline')
+        .requiredOption('-p, --pipeline <id>', 'Pipeline ID')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const pipelineId = parseInt(options.pipeline, 10)
+            if (isNaN(pipelineId)) {
+                console.error(`Invalid pipeline ID: ${options.pipeline}`)
+                process.exit(1)
+            }
+            const jobs: Array<Job> = await getPipelineJobs(pipelineId)
+            if (!jobs || jobs.length === 0) {
+                console.error(`No jobs found for pipeline ${pipelineId}`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(JSON.stringify(jobs, null, 2))
+            } else {
+                const filtered = jobs.map((j: Job) => {
+                    const { id, name, stage, status, duration, failure_reason } = j
+                    return { id, name, stage, status, duration, failure_reason }
+                })
+                console.log(JSON.stringify(filtered, null, 2))
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-pipeline-jobs')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-project-pipeline-latest.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getLatestPipeline, type Pipeline, getPipelineJobs, type Job } from '../lib/gitlab'
+import { isMain } from '../lib/is_main'
+
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('latest')
+        .description('Show jobs for the latest pipeline on the current branch')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const pipeline: Pipeline | undefined = await getLatestPipeline()
+            if (!pipeline) {
+                console.error('No pipeline found for the current branch')
+                process.exit(1)
+            }
+            const { id, status, ref, web_url } = pipeline
+            console.log(JSON.stringify({ id, status, ref, web_url }, null, 2))
+            const jobs: Array<Job> = await getPipelineJobs(pipeline.id)
+            if (!jobs || jobs.length === 0) {
+                console.error(`No jobs found for pipeline ${pipeline.id}`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(JSON.stringify(jobs, null, 2))
+            } else {
+                const filtered = jobs.map((j: Job) => {
+                    const { id, name, stage, status, duration, failure_reason } = j
+                    return { id, name, stage, status, duration, failure_reason }
+                })
+                console.log(JSON.stringify(filtered, null, 2))
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-pipeline-latest')) {
+    await create().parseAsync(Bun.argv)
+}