ya-git-jira 1.3.0 → 1.5.0

package/bin/git-bump.ts

@@ -1,12 +1,15 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { createBranch, getCurrentBranch } from "../lib/git"
 import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
 import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
 
 export function create(): Command {
-    const program = new Command()
+    const program: Command = new Command()
     program
+        .version(version)
         .name('bump')
         .description('Bump the version number in the current branch')
         .action(async () => {
@@ -27,8 +30,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,15 +1,18 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
 import { myUnresolvedIssues } from "../lib/jira"
 import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
 
 export function create(): Command {
-    const program = new Command()
+    const program: Command = new Command()
     program
-        .name('issues')
+        .version(version)
+        .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 +22,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,40 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getIssue } from "../lib/jira"
+import { isMain } from '../lib/is_main'
+import { getJiraConfig } from '../lib/jira'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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,27 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
-import { getIssue } from "../lib/jira"
+import { getPackageVersion } from '../lib/package'
 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'
+const version = await getPackageVersion()
 
 export function create(): Command {
-    const program = new Command()
+    const program: Command = new Command()
     program
+        .version(version)
         .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,9 +1,11 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
 import { createBranch } from "../lib/git"
 import { getIssue } from "../lib/jira"
 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()
@@ -12,8 +14,9 @@ function toKebab(s: string): string {
 }
 
 export function create(): Command {
-    const program = new Command()
+    const program: Command = new Command()
     program
+        .version(version)
         .name('start')
         .description('Start working on an issue by creating a branch')
         .argument('issue', 'Issue ID')
@@ -32,8 +35,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,27 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
 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'
+const version = await getPackageVersion()
 
 export function create(): Command {
-    const program = new Command()
+    const program: Command = new Command()
     program
+        .version(version)
         .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,35 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import { getGroups } from '../lib/gitlab'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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,25 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+import list from './git-lab-group-list'
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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,41 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getMyMergeRequestsInProgress } 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('active')
+        .description('List my MRs in progress')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const merges = await getMyMergeRequestsInProgress();
+            if (!merges) {
+                console.error(`No MRs!`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(merges)
+                process.exit(0)
+            }
+            else {
+                const filtered = merges.map(m => {
+                    const { title, web_url, source_branch, target_branch } = m
+                    return { title, web_url, source_branch, target_branch }
+                })
+                console.log(filtered)
+            }
+        })
+    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,36 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getMyMergeRequestsToReview, type MergeRequest } 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('todo')
+        .description('MRs needing my review')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const mrs: MergeRequest[] = await getMyMergeRequestsToReview()
+            if (options.verbose) {
+                console.log(mrs)
+            }
+            else {
+                const filtered = mrs.map(mr => {
+                    const { title, web_url, source_branch, target_branch } = mr
+                    return { title, web_url, source_branch, target_branch }
+                })
+                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-list.ts

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

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
+
+import list from './git-lab-merge-train-list'
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('train')
+        .description('Commands for working with GitLab merge trains.')
+        .addCommand(list())
+        .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,29 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import todo from './git-lab-merge-todo'
+import active from './git-lab-merge-active'
+import train from './git-lab-merge-train'
+
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('merge')
+        .description('Commands for working with GitLab merge requests')
+        .addCommand(active())
+        .addCommand(todo())
+        .addCommand(train())
+        .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,27 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import { getNamespaces } from '../lib/gitlab/namespace'
+
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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,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-namespace-list'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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,18 +1,21 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
 import { Command } from 'commander'
-import { getProjects, type Project } from "../lib/gitlab"
+import { getPackageVersion } from '../lib/package'
+import { getProjects, type Project } from "../lib/gitlab/project"
 import { isMain } from '../lib/is_main'
+const version = await getPackageVersion()
 
 export function create(): Command {
-    const program = new Command()
+    const program: Command = new Command()
     program
-        .name('projects')
+        .version(version)
+        .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 +34,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,46 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getProjectPipelines, type Pipeline } from "../lib/gitlab"
+import { isMain } from '../lib/is_main'
+import debug from 'debug'
+
+const version = await getPackageVersion()
+const dlog = debug('git-lab-project-pipeline-list')
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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)
+            dlog(`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,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-pipeline-list'
+const version = await getPackageVersion()
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .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,43 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { findProject } from "../lib/gitlab/project"
+import { getRemote } 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('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)
+}