ya-git-jira 1.3.0 → 1.4.0

package/bin/git-bump.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { createBranch, getCurrentBranch } from "../lib/git"
 import { Command } from 'commander'
@@ -27,8 +27,8 @@ export function create(): Command {
     return program
 }
 
+export default create
+
 if (isMain('git-bump')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/{git-jira-issues.ts → git-jira-issue-list.ts}

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
 import { myUnresolvedIssues } from "../lib/jira"
@@ -7,9 +7,9 @@ import { isMain } from '../lib/is_main'
 export function create(): Command {
     const program = new Command()
     program
-        .name('issues')
+        .name('list')
         .description('List your unresolved issues')
-        .action(async (options) => {
+        .action(async () => {
             const issues = await myUnresolvedIssues()
             console.log(`You have ${issues.length} unresolved issues`)
             issues.forEach(issue => {
@@ -19,8 +19,8 @@ export function create(): Command {
     return program
 }
 
-if (isMain('git-jira-issues')) {
+export default create
+
+if (isMain('git-jira-issue-list')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/git-jira-issue-show.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getIssue } from "../lib/jira"
+import { isMain } from '../lib/is_main'
+import { getJiraConfig } from '../lib/jira'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('show')
+        .description('Show information about one issue')
+        .argument('issue', 'Issue ID')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (issueId: string, options) => {
+            const issue = await getIssue(issueId)
+            if (!issue) {
+                console.error(`Issue ${issueId} not found`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(issue)
+            } else {
+                const { host } = await getJiraConfig()
+                const summary = issue.fields.summary
+                const url = `https://${host}/browse/${issueId}`
+                console.log({ issueId, summary, url })
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-jira-issue-show')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-jira-issue.ts

@@ -1,38 +1,25 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
-import { getIssue } from "../lib/jira"
 import { isMain } from '../lib/is_main'
-import { getJiraConfig } from '../lib/jira'
+
+import list from './git-jira-issue-list'
+import show from './git-jira-issue-show'
 
 export function create(): Command {
     const program = new Command()
     program
         .name('issue')
-        .description('Get information about an issue')
-        .argument('issue', 'Issue ID')
-        .option('-v, --verbose', 'Verbose output')
-        .option('-u, --url', 'Show the URL of the issue')
-        .action(async (issueId: string, options) => {
-            const { host } = await getJiraConfig()
-            const issue = await getIssue(issueId)
-            if (!issue) {
-                console.error(`Issue ${issueId} not found`)
-                process.exit(1)
-            }
-            if (options.verbose) {
-                console.log(issue)
-                process.exit(0)
-            }
-            if (options.url) {
-                console.log(`https://${host}/browse/${issueId}`)
-            }
-        })
+        .description('Commands for working with issues')
+        .addCommand(list())
+        .addCommand(show())
+        .action(() => program.help()
+        )
     return program
 }
 
+export default create
+
 if (isMain('git-jira-issue')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/git-jira-start.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
 import { createBranch } from "../lib/git"
@@ -32,8 +32,8 @@ export function create(): Command {
     return program
 }
 
-if (isMain('git-jira-issues')) {
+export default create
+
+if (isMain('git-jira-start')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/git-jira.ts

@@ -1,24 +1,24 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
 import { isMain } from '../lib/is_main'
 import start from './git-jira-start'
 import issue from './git-jira-issue'
-import issues from './git-jira-issues'
+import issues from './git-jira-issue-list'
 
 export function create(): Command {
     const program = new Command()
     program
         .name('jira')
-        .description('A set of commands for working with Jira')
+        .description('Commands for working with Jira')
         .addCommand(start())
         .addCommand(issue())
         .addCommand(issues())
     return program
 }
 
+export default create
+
 if (isMain('git-jira')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/git-lab-group-list.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { isMain } from '../lib/is_main'
+import { getGroups } from '../lib/gitlab'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('list')
+        .description('List groups for the current user')
+        .option("-v, --verbose", "Verbose output")
+        .action(async (options) => {
+            const groups = await getGroups()
+            if (options.verbose)
+                console.log(groups)
+            else {
+                const filtered = groups.map(g => {
+                    const { id, name, full_path } = g
+                    return { id, name, full_path }
+                })
+                console.log(filtered)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-group-list')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-group.ts

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

package/bin/git-lab-merge-active.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { whoami, type User } from "../lib/gitlab"
+import { isMain } from '../lib/is_main'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('active')
+        .description('List my active MRs')
+        .option('-v, --verbose', 'Verbose output')
+
+        .action(async (options) => {
+            const user: User = await whoami()
+            if (!user) {
+                console.error(`No user!`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(user)
+                process.exit(0)
+            }
+            else {
+                console.log(user.username)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-merge-active')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-merge-todo.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getMergeRequestsAssignedToMe, type MergeRequest } from "../lib/gitlab"
+import { isMain } from '../lib/is_main'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('todo')
+        .description('MRs needing my review')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const mrs: MergeRequest[] = await getMergeRequestsAssignedToMe()
+            if (options.verbose) {
+                console.log(mrs)
+            }
+            else {
+                const filtered = mrs.map(mr => {
+                    const { id, title, web_url, source_branch, target_branch, merge_status } = mr
+                    return { id, title, web_url, source_branch, target_branch, merge_status }
+                })
+                console.log(filtered)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-merge-todo')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-merge-train.ts

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

package/bin/git-lab-merge.ts

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

package/bin/git-lab-namespace-list.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { isMain } from '../lib/is_main'
+import { getNamespaces } from '../lib/gitlab'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('list')
+        .description('List namespaces for the current user')
+        .action(async () => {
+            const namespaces = await getNamespaces()
+            console.log(namespaces)
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-namespace-list')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-namespace.ts

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

package/bin/{git-lab-projects.ts → git-lab-project-list.ts}

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
 import { getProjects, type Project } from "../lib/gitlab"
@@ -7,12 +7,12 @@ import { isMain } from '../lib/is_main'
 export function create(): Command {
     const program = new Command()
     program
-        .name('projects')
+        .name('list')
         .description('List projects for current user')
         .option('-v, --verbose', 'Verbose output')
-        .argument('[path...]', 'Namespace paths to filter by')
-        .action(async (paths: string[], options) => {
-            const projects: Array<Project> = await getProjects(paths)
+        .option('-m, --match <match>', 'Match projects with paths containing <match>')
+        .action(async (options) => {
+            const projects: Array<Project> = await getProjects(options.match)
             if (!projects) {
                 console.error(`No projects!`)
                 process.exit(1)
@@ -31,8 +31,8 @@ export function create(): Command {
     return program
 }
 
-if (isMain('git-lab-projects')) {
+export default create
+
+if (isMain('git-lab-project-list')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

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

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getProjectPipelines, type Pipeline } from "../lib/gitlab"
+import { isMain } from '../lib/is_main'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('list')
+        .description('List recent successful pipelines')
+        .option('-v, --verbose', 'Verbose output')
+        .option('-d, --days <days>', 'Number of days to look back', '7')
+        .option('-s, --status <status>', 'Status of pipelines to list: success | runnning | ', 'success')
+        .action(async (options) => {
+            const pipelines: Array<Pipeline> = await getProjectPipelines(options)
+            console.debug(`pipelines: ${pipelines}`)
+            if (!pipelines) {
+                console.error(`No pipelines!`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(pipelines)
+            }
+            else {
+                let filtered = pipelines.map((p: Pipeline) => {
+                    const { id, web_url, updated_at, ref, sha } = p
+                    return { id, web_url, updated_at, ref, sha }
+                })
+                console.log(filtered)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-pipeline-list')) {
+    await create().parseAsync(Bun.argv)
+}

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

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

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

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { findProject } from "../lib/gitlab"
+import { getRemote } from '../lib/git'
+import { isMain } from '../lib/is_main'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('whereami')
+        .description('Show current project based on current directory')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const ssh_url = await getRemote();
+            if (!ssh_url) {
+                console.error(`No remote!`)
+                process.exit(1)
+            }
+            console.log(`Remote: ${ssh_url}`)
+            const project = await findProject(ssh_url);
+            if (!project) {
+                console.error(`No project!`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(project)
+            } else {
+                const { id, name, path_with_namespace, ssh_url_to_repo } = project
+                console.log({id, name, path_with_namespace, ssh_url_to_repo })
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-whereami')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/git-lab-project.ts

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

package/bin/git-lab-whoami.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
 import { whoami, type User } from "../lib/gitlab"
@@ -27,8 +27,8 @@ export function create(): Command {
     return program
 }
 
+export default create
+
 if (isMain('git-lab-whoami')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/git-lab.ts

@@ -1,22 +1,30 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
 import { isMain } from '../lib/is_main'
+
+import groups from './git-lab-group'
+import merges from './git-lab-merge'
+import namespaces from './git-lab-namespace'
+import projects from './git-lab-project'
 import whoami from './git-lab-whoami'
-import projects from './git-lab-projects'
 
 export function create(): Command {
     const program = new Command()
     program
         .name('lab')
-        .description('A set of commands for working with GitLab')
-        .addCommand(whoami())
+        .description('Commands for working with GitLab')
+        .addCommand(groups())
+        .addCommand(merges())
+        .addCommand(namespaces())
         .addCommand(projects())
+        .addCommand(whoami())
+        .action(() => program.help())
     return program
 }
 
-if (isMain('git-jira')) {
+export default create
+
+if (isMain('git-lab')) {
     await create().parseAsync(Bun.argv)
 }
-
-export default create

package/bin/gitj.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import bump from './git-bump'
 import jira from './git-jira'

package/build.ts

@@ -4,7 +4,7 @@ import { glob } from 'glob'
 const result: BuildOutput = await Bun.build({
     entrypoints: ['./index.ts', ...glob.sync('./bin/*.ts')],
     outdir: './dist',
-    target: 'bun'
+    target: 'bun',
 })
 
 if (result.success) {

package/lib/gitlab.ts

@@ -18,11 +18,27 @@ export async function getGitlabConfig(): Promise<GitlabConfig> {
     return { host, user, token }
 }
 
-export async function get(endpoint: string): Promise<JSONValue> {
+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 gitlabApi(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith("/")) {
+        console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
     const method = "GET"
     const { host, token } = await getGitlabConfig()
     const base = `https://${host}/api/v4`
-    const uri = `${base}/${endpoint}`
+    const requested = 100
+    const sep = endpoint.includes('?') ? '&' : '?'
+    const uri = `${base}/${endpoint}${sep}per_page=${requested}`
     const headers = new Headers()
     headers.append("Accept", "application/json")
     headers.append('Private-Token', token)
@@ -30,9 +46,20 @@ export async function get(endpoint: string): Promise<JSONValue> {
         method,
         headers,
     }
-    const request = new Request(uri, options)
+    let request = new Request(uri, options)
     const response = await fetch(request)
-    return await response.json()
+    let link = getNextLink(response.headers.get('Link'))
+    let partial = (await response.json()) as Array<JSONValue>
+    let result: Array<JSONValue> = partial
+    while (partial.length == requested && link)
+    {
+        let request = new Request(link, options)
+        const next_response = await fetch(request)
+        link = getNextLink(next_response.headers.get('Link'))
+        partial = (await next_response.json()) as Array<JSONValue>
+        result = result.concat(partial)
+    }
+    return result;
 }
 
 export type User = JSONValue & {
@@ -43,7 +70,7 @@ export type User = JSONValue & {
 }
 
 export async function whoami(): Promise<User> {
-    return await get("/user") as User
+    return await gitlabApi("user") as User
 }
 
 export type Project = JSONValue & {
@@ -55,32 +82,128 @@ export type Project = JSONValue & {
     ssh_url_to_repo: string
 }
 
-export async function getProjects(paths: string[]): Promise<Array<Project>> {
-    let search: string = ""
-    if (paths.length > 0) {
-        search = '&search=' + paths.join(",")
+export async function getProjects(match: string): Promise<Array<Project>> {
+    let search = ''
+    if (match) {
+        const m = encodeURIComponent(match)
+        search = `&search=${m}`
+    }
+    const projects = await gitlabApi(`projects?membership=true&simple=true${search}`)
+    if (!projects) {
+        throw new Error(`No projects!`)
+    } else if (!Array.isArray(projects)) {
+        console.log(projects)
+        throw new Error(`Projects is not an array!`)
     }
-    return await get(`/projects?visibility=private&membership=true&simple=true${search}`) as Array<Project>
+    const projs = projects as Array<Project>
+
+    const filtered = projs.filter((p: Project): boolean => {
+        return p.path_with_namespace.toLowerCase().includes(match.toLowerCase())
+    })
+    return filtered
 }
 
 // git@gitlab.com:etagen-internal/linear-generator-config.git
-export async function findProject(ssh_url: string): Promise<Project> {
+export async function findProject(ssh_url: string): Promise<Project | undefined> {
     const parts = ssh_url.split(':')
     if (parts.length != 2) {
         throw new Error(`${ssh_url} is invalid, could not be split into two parts at :`)
     }
     const name = path.basename(parts[1], '.git')
 
-    const projects = await getProjects([name])
+    const projects = await getProjects(name) as Array<Project>
     const project = projects.find((p: Project): boolean => {
         return p.ssh_url_to_repo === ssh_url
     })
+    return project
+}
+
+export async function projectScopedGet(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith("/")) {
+        console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
+    const method = "GET"
+    const { host, token } = await getGitlabConfig()
+    const remote = await getRemote()
+    const project = await findProject(remote)
     if (!project) {
-        throw new Error(`No project with ssh_url_to_repo ${ssh_url} found`)
+        throw new Error(`Could not find project for remote ${remote}`)
     }
-    return project
+    const base = `https://${host}/api/v4/projects/${project.id}`
+    const uri = `${base}/${endpoint}`
+    console.debug(`projectScopedGet 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 response.json()
 }
 
 export async function getMergeRequest(id: string): Promise<JSONValue> {
-    return await get(`/merge_requests/${id}`)
+    return await projectScopedGet(`merge_requests/${id}`)
+}
+
+export async function getNamespaces(): Promise<JSONValue> {
+    return await gitlabApi(`namespaces`)
+}
+
+export type Group = JSONValue & {
+    id: number
+    name: string
+    full_path: string
+}
+
+export async function getGroups(): Promise<Array<Group>> {
+    return await gitlabApi(`groups`) as Array<Group>
+}
+
+export type MergeRequest = JSONValue & {
+    id: number
+    title : string
+    description : string
+    state : string
+    source_branch: string
+    target_branch: string
+    web_url: string
+    merge_status: string
+}
+
+export async function getMergeRequestsAssignedToMe() : Promise<Array<MergeRequest>>
+{
+    const me = await whoami()
+    return await gitlabApi(`merge_requests?state=opened&reviewer_id=${me.id}`) as Array<MergeRequest>
+}
+
+export type Pipeline = JSONValue & {
+    id: number
+    status: string
+    ref: string
+    sha: string
+    web_url: string
+    updated_at: string  // datetime string like "2021-03-18T15:00:00.000Z"
+}
+
+export type PipelineStatus = 'success' | 'running'
+
+export interface GetPipelineOptions {
+    days: number
+    status: PipelineStatus
+}
+
+export async function getProjectPipelines(options: GetPipelineOptions): Promise<Array<Pipeline>> {
+    const { days, status } = options
+    const me = await whoami()
+    const username = me.username
+    const date = new Date()
+    const pastDate = date.getDate() - days;
+    date.setDate(pastDate)
+    const updated = date.toISOString()
+    console.debug(`updated: ${updated}`)
+    return await projectScopedGet(`pipelines?status=${status}&username=${username}&updated_after=${updated}`) as Array<Pipeline>
 }

package/lib/is_main.ts

@@ -1,5 +1,24 @@
 import path from 'node:path'
+
+function justBase(filename: string): string {
+    const ext = path.extname(filename)
+    const base = path.basename(filename, ext)
+    return base
+}
+
 export function isMain(self: string): boolean {
-    const exe = path.basename(Bun.argv[1]).split('.')[0]
-    return exe == self || import.meta.main
+    const arg1 = Bun.argv[1]
+    const argv1Base = justBase(arg1)
+    const selfBase = justBase(self)
+    const result = argv1Base === selfBase
+    // if (result) {
+    //     console.log({
+    //         arg1,
+    //         self,
+    //         argv1Base,
+    //         selfBase,
+    //         result,
+    //     })
+    // }
+    return result
 }

package/lib/jira.ts

@@ -25,11 +25,14 @@ export async function getJiraConfig(): Promise<JiraConfig> {
     return { host, token }
 }
 
-export async function get(endpoint: string): Promise<JSONValue> {
+export async function jiraApi(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith("/")) {
+        console.warn(`jiraApi: endpoint ${endpoint} starts with /`)
+        endpoint = endpoint.slice(1)
+    }
     const method = "GET"
     const { host, token } = await getJiraConfig()
-    const base = `https://${host}/rest/api/3`
-    const uri = `${base}/${endpoint}`
+    const uri = `https://${host}/rest/api/3/${endpoint}`
     const auth = `Basic ${token}`
     const headers = new Headers()
     headers.append("Authorization", auth)
@@ -40,11 +43,13 @@ export async function get(endpoint: string): Promise<JSONValue> {
     }
     const request = new Request(uri, options)
     const response = await fetch(request)
-    return await response.json()
+    const result = await response.json()
+    return result;
 }
 
 export async function getIssue(issue: string): Promise<Issue> {
-    return await get(`/issue/${issue}`) as Issue
+    const result = await jiraApi(`issue/${issue}`) as Issue
+    return result
 }
 
 type Myself = JSONValue & {
@@ -52,7 +57,7 @@ type Myself = JSONValue & {
 }
 
 export async function getMyself(): Promise<Myself> {
-    return await get("/myself") as Myself
+    return await jiraApi("/myself") as Myself
 }
 
 type SearchResponse = JSONValue & {
@@ -63,6 +68,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 get(`/search?jql=${encodeURIComponent(jql)}`) as SearchResponse
+    const issues = await jiraApi(`/search?jql=${encodeURIComponent(jql)}`) as SearchResponse
     return issues.issues
 }

package/package.json

@@ -1,16 +1,27 @@
 {
   "name": "ya-git-jira",
   "description": "git extensions for Jira integration. Assumes bun is installed.",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "module": "dist/index.js",
   "type": "module",
   "bin": {
     "git-bump": "dist/bin/git-bump.js",
+    "git-jira-issue-list": "dist/bin/git-jira-issue-list.js",
+    "git-jira-issue-show": "dist/bin/git-jira-issue-show.js",
     "git-jira-issue": "dist/bin/git-jira-issue.js",
-    "git-jira-issues": "dist/bin/git-jira-issues.js",
     "git-jira-start": "dist/bin/git-jira-start.js",
     "git-jira": "dist/bin/git-jira.js",
-    "git-lab-projects": "dist/bin/git-lab-projects.js",
+    "git-lab-group": "dist/bin/git-lab-group.js",
+    "git-lab-merge-active": "dist/bin/git-lab-merge-active.js",
+    "git-lab-merge-todo": "dist/bin/git-lab-merge-todo.js",
+    "git-lab-merge": "dist/bin/git-lab-merge.js",
+    "git-lab-namespace-list": "dist/bin/git-lab-namespace-list.js",
+    "git-lab-namespace": "dist/bin/git-lab-namespace.js",
+    "git-lab-project-list": "dist/bin/git-lab-project-list.js",
+    "git-lab-project-pipeline": "dist/bin/git-lab-project-pipeline.js",
+    "git-lab-project-pipeline-list": "dist/bin/git-lab-project-pipeline-list.js",
+    "git-lab-project-whereami": "dist/bin/git-lab-project-whereami.js",
+    "git-lab-project": "dist/bin/git-lab-project.js",
     "git-lab-whoami": "dist/bin/git-lab-whoami.js",
     "git-lab": "dist/bin/git-lab.js",
     "gitj": "dist/bin/gitj.js"
@@ -21,7 +32,8 @@
   },
   "devDependencies": {
     "@types/commander": "^2.12.2",
-    "bun-types": "latest"
+    "bun-types": "latest",
+    "typescript": "latest"
   },
   "directories": {
     "lib": "lib"

package/tests/all-help.test.ts

@@ -0,0 +1,19 @@
+import { readdirSync } from 'fs';
+import { describe, expect, test } from 'bun:test';
+import { doCommand } from '..';
+
+describe('bin scripts', () => {
+    const binDir = './bin';
+
+    const scripts = readdirSync(binDir).filter((file) => {
+        return file.endsWith('.ts');
+    });
+
+    scripts.forEach((script) => {
+        const stem = script.split('/').pop()?.split('-').pop()?.split('.').shift();
+        test(`"${script} --help" should contain 'Usage: ${stem}'"`, async () => {
+            const output = await doCommand(['bun', 'run', `${binDir}/${script}`, '--help']);
+            expect(output).toContain(`Usage: ${stem}`);
+        });
+    });
+});

package/tests/git.test.ts

@@ -13,13 +13,13 @@ test("getRemote", async (): Promise<void> => {
 test("findProject linear-generator", async (): Promise<void> => {
     const ssh_url = "git@gitlab.com:etagen-internal/linear-generator.git"
     const project = await findProject(ssh_url)
-    expect(project.ssh_url_to_repo).toBe(ssh_url)
-    expect(project.id).toBe(4053065)
-})
+    expect(project?.ssh_url_to_repo).toBe(ssh_url)
+    expect(project?.id).toBe(4053065)
+}, 15000)
 
 test("findProject eta-lib/base", async (): Promise<void> => {
     const ssh_url = "git@gitlab.com:etagen-internal/eta-lib/base.git"
     const project = await findProject(ssh_url)
-    expect(project.ssh_url_to_repo).toBe(ssh_url)
-    expect(project.id).toBe(42470523)
-})
+    expect(project?.ssh_url_to_repo).toBe(ssh_url)
+    expect(project?.id).toBe(42470523)
+}, 15000)

package/tests/gitj.test.ts

@@ -10,7 +10,7 @@ test("gitj works", async (): Promise<void> => {
     const { out, code }: SpawnResult = await spawn(["bun", "run", "bin/gitj.ts"])
     expect(out).toMatch("Usage:")
     expect(out).toMatch("Bump the version number in the current branch")
-    expect(out).toMatch("A set of commands for working with Jira")
+    expect(out).toMatch("Commands for working with Jira")
     expect(code).toBe(0)
 })