ya-git-jira 1.6.0 → 2.0.0

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)
+}

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { getJobLog } 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('log')
+        .description('Download a job log')
+        .requiredOption('-j, --job <id>', 'Job ID')
+        .option('-t, --tail <lines>', 'Show only the last N lines')
+        .action(async (options) => {
+            const jobId = parseInt(options.job, 10)
+            if (isNaN(jobId)) {
+                console.error(`Invalid job ID: ${options.job}`)
+                process.exit(1)
+            }
+            const log = await getJobLog(jobId)
+            if (!log) {
+                console.error(`No log output for job ${jobId}`)
+                process.exit(1)
+            }
+            if (options.tail) {
+                const n = parseInt(options.tail, 10)
+                if (isNaN(n)) {
+                    console.error(`Invalid --tail value: ${options.tail}`)
+                    process.exit(1)
+                }
+                const lines = log.split('\n')
+                const tail = lines.slice(-n)
+                process.stdout.write(tail.join('\n'))
+            } else {
+                process.stdout.write(log)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('git-lab-project-pipeline-log')) {
+    await create().parseAsync(Bun.argv)
+}

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

@@ -3,7 +3,10 @@
 import { Command } from 'commander'
 import { getPackageVersion } from '../lib/package'
 import { isMain } from '../lib/is_main'
+import jobs from './git-lab-project-pipeline-jobs'
+import latest from './git-lab-project-pipeline-latest'
 import list from './git-lab-project-pipeline-list'
+import log from './git-lab-project-pipeline-log'
 const version = await getPackageVersion()
 
 export function create(): Command {
@@ -12,7 +15,10 @@ export function create(): Command {
         .version(version)
         .name('pipeline')
         .description('Commands for working with GitLab pipelines')
+        .addCommand(jobs())
+        .addCommand(latest())
         .addCommand(list())
+        .addCommand(log())
         .action(() => program.help())
     return program
 }

package/bin/git-lab-project.ts

@@ -4,6 +4,8 @@ import { Command } from 'commander'
 import { getPackageVersion } from '../lib/package'
 import { isMain } from '../lib/is_main'
 import list from './git-lab-project-list'
+import mr from './git-lab-project-mr'
+import pipeline from './git-lab-project-pipeline'
 import whereami from './git-lab-project-whereami'
 const version = await getPackageVersion()
 
@@ -11,9 +13,11 @@ export function create(): Command {
     const program: Command = new Command()
     program
         .version(version)
-        .name('projects')
+        .name('project')
         .description('Commands for working with GitLab projects')
         .addCommand(list())
+        .addCommand(mr())
+        .addCommand(pipeline())
         .addCommand(whereami())
         .action(() => {
             program.help()

package/bin/gitj-install-skills.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { getPackageVersion } from '../lib/package'
+import { findPackageJson } from '../lib/package'
+import { isMain } from '../lib/is_main'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+const version = await getPackageVersion()
+
+const frameworks = ['opencode', 'copilot', 'claude'] as const
+type Framework = typeof frameworks[number]
+
+const skillNames = ['git-jira', 'git-lab', 'git-confluence']
+
+function getSkillsSourceDir(): string {
+    const packageJsonPath = findPackageJson()
+    if (!packageJsonPath) {
+        throw new Error('Cannot find package.json for ya-git-jira')
+    }
+    const packageRoot = path.dirname(packageJsonPath)
+    const skillsDir = path.join(packageRoot, '.opencode', 'skills')
+    if (!fs.existsSync(skillsDir)) {
+        throw new Error(`Skills directory not found: ${skillsDir}`)
+    }
+    return skillsDir
+}
+
+function getTargetDir(framework: Framework): string {
+    const home = os.homedir()
+    switch (framework) {
+        case 'opencode':
+            return path.join(home, '.config', 'opencode', 'skills')
+        case 'copilot':
+            return path.join(home, '.copilot', 'skills')
+        case 'claude':
+            return path.join(process.cwd(), '.claude', 'skills')
+    }
+}
+
+function installSkills(framework: Framework, copy: boolean): void {
+    const sourceDir = getSkillsSourceDir()
+    const targetDir = getTargetDir(framework)
+
+    fs.mkdirSync(targetDir, { recursive: true })
+
+    for (const name of skillNames) {
+        const source = path.join(sourceDir, name)
+        const target = path.join(targetDir, name)
+
+        if (fs.existsSync(target)) {
+            const stat = fs.lstatSync(target)
+            if (stat.isSymbolicLink()) {
+                fs.unlinkSync(target)
+            } else if (stat.isDirectory()) {
+                console.error(`${target} already exists as a directory -- skipping (use --force to overwrite)`)
+                continue
+            }
+        }
+
+        if (copy) {
+            fs.cpSync(source, target, { recursive: true })
+            console.log(`copied ${name} -> ${target}`)
+        } else {
+            fs.symlinkSync(source, target)
+            console.log(`linked ${name} -> ${target}`)
+        }
+    }
+}
+
+function forceInstallSkills(framework: Framework, copy: boolean): void {
+    const sourceDir = getSkillsSourceDir()
+    const targetDir = getTargetDir(framework)
+
+    fs.mkdirSync(targetDir, { recursive: true })
+
+    for (const name of skillNames) {
+        const source = path.join(sourceDir, name)
+        const target = path.join(targetDir, name)
+
+        if (fs.existsSync(target) || fs.lstatSync(target).isSymbolicLink()) {
+            fs.rmSync(target, { recursive: true, force: true })
+        }
+
+        if (copy) {
+            fs.cpSync(source, target, { recursive: true })
+            console.log(`copied ${name} -> ${target}`)
+        } else {
+            fs.symlinkSync(source, target)
+            console.log(`linked ${name} -> ${target}`)
+        }
+    }
+}
+
+export function create(): Command {
+    const program: Command = new Command()
+    program
+        .version(version)
+        .name('install-skills')
+        .description('Install AI agent skills for a coding framework')
+        .argument('<framework>', `framework to install for (${frameworks.join(', ')})`)
+        .option('--copy', 'copy files instead of creating symlinks')
+        .option('--force', 'overwrite existing skill directories')
+        .action(async (framework: string, options: { copy?: boolean; force?: boolean }) => {
+            if (!frameworks.includes(framework as Framework)) {
+                console.error(`Unknown framework: ${framework}`)
+                console.error(`Supported frameworks: ${frameworks.join(', ')}`)
+                process.exit(1)
+            }
+
+            if (options.force) {
+                forceInstallSkills(framework as Framework, !!options.copy)
+            } else {
+                installSkills(framework as Framework, !!options.copy)
+            }
+        })
+    return program
+}
+
+export default create
+
+if (isMain('gitj-install-skills')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/gitj.ts

@@ -6,8 +6,12 @@
 // from the command line and then call the appropriate subcommand.
 
 import { Command } from 'commander'
+import { formatCommandTree } from '../lib/help.ts'
 import { getPackageVersion } from '../lib/package'
+import api from './git-api'
 import bump from './git-bump'
+import confluence from './git-confluence'
+import installSkills from './gitj-install-skills'
 import jira from './git-jira'
 import lab from './git-lab'
 const version = await getPackageVersion()
@@ -16,10 +20,18 @@ export function create(): Command {
     const program: Command = new Command()
     program
         .version(version)
+        .option('--help-all', 'Show full command tree')
+        .addCommand(api())
         .addCommand(bump())
+        .addCommand(confluence())
+        .addCommand(installSkills())
         .addCommand(jira())
         .addCommand(lab())
         .action(() => {
+            if (program.opts().helpAll) {
+                console.log(formatCommandTree(program))
+                return
+            }
             program.help()
         })
     return program