@meistrari/tela-cli 0.7.0 → 0.7.5

package/src/git.ts

@@ -1,457 +0,0 @@
-import { basename } from 'node:path'
-import { inspectSavedConfig } from './config.ts'
-import { createUserFacingError } from './errors.ts'
-import { resolveSshPrivateKeyPath } from './forgejo.ts'
-import {
-    CommandError,
-    runCommand,
-    type CommandResult,
-    type RunCommandOptions,
-} from './process.ts'
-import type { TelaCliGitSshKey } from './types.ts'
-
-export interface GitStatusEntry {
-    index: string
-    worktree: string
-    path: string
-}
-
-export interface GitStatusCounts {
-    staged: number
-    unstaged: number
-    untracked: number
-    total: number
-}
-
-type GitSshHostKeyPolicy = 'default' | 'accept-new'
-
-interface GitRunOptions extends Omit<RunCommandOptions, 'env'> {
-    requireConfiguredSsh?: boolean
-    sshHostKeyPolicy?: GitSshHostKeyPolicy
-}
-
-function quoteForShell(value: string): string {
-    return `'${value.replaceAll('\'', `'"'"'`)}'`
-}
-
-export function buildGitSshCommand(
-    privateKeyPath: string,
-    options: {
-        hostKeyPolicy?: GitSshHostKeyPolicy
-    } = {},
-): string {
-    const args = [
-        `-i ${quoteForShell(privateKeyPath)}`,
-        '-o IdentitiesOnly=yes',
-    ]
-
-    if (options.hostKeyPolicy === 'accept-new') {
-        args.push('-o StrictHostKeyChecking=accept-new')
-    }
-
-    return `ssh ${args.join(' ')}`
-}
-
-export function isSshRemoteUrl(remoteUrl: string): boolean {
-    const trimmed = remoteUrl.trim()
-    return /^ssh:\/\//i.test(trimmed) || /^[^\s@]+@[^\s:]+:.+$/.test(trimmed)
-}
-
-function resolveConfiguredGitSshKey(requireConfiguredSsh: boolean): TelaCliGitSshKey | null {
-    const inspection = inspectSavedConfig()
-    if (!inspection.exists) {
-        if (requireConfiguredSsh) {
-            throw createUserFacingError({
-                code: 'git_ssh_key_config_missing',
-                summary: 'Tela CLI is not configured with a Git SSH key.',
-                fixes: [
-                    'Run `tela setup` and choose the SSH key to force on Git operations.',
-                ],
-            })
-        }
-
-        return null
-    }
-
-    if (!inspection.valid || !inspection.config) {
-        if (requireConfiguredSsh) {
-            throw createUserFacingError({
-                code: 'git_ssh_key_config_invalid',
-                summary: 'Tela CLI config is invalid, so the Git SSH key could not be loaded.',
-                details: inspection.error,
-                fixes: [
-                    'Run `tela setup` to rewrite the config and choose the SSH key again.',
-                ],
-            })
-        }
-
-        return null
-    }
-
-    if (!inspection.config.gitSshKey) {
-        if (requireConfiguredSsh) {
-            throw createUserFacingError({
-                code: 'git_ssh_key_missing',
-                summary: 'No Git SSH key is configured.',
-                fixes: [
-                    'Run `tela setup` again and choose the SSH key to use for Git operations.',
-                ],
-            })
-        }
-
-        return null
-    }
-
-    try {
-        return {
-            ...inspection.config.gitSshKey,
-            privateKeyPath: resolveSshPrivateKeyPath(inspection.config.gitSshKey.privateKeyPath),
-        }
-    }
-    catch (error) {
-        if (requireConfiguredSsh) {
-            throw createUserFacingError({
-                code: 'git_ssh_key_invalid',
-                summary: 'The configured Git SSH private key is unavailable.',
-                details: error instanceof Error ? error.message : String(error),
-                fixes: [
-                    'Restore the configured private key file, or run `tela setup` again and choose another SSH key.',
-                ],
-                cause: error,
-            })
-        }
-
-        return null
-    }
-}
-
-function buildGitEnv(
-    requireConfiguredSsh: boolean,
-    sshHostKeyPolicy: GitSshHostKeyPolicy = 'default',
-): Record<string, string> | undefined {
-    const gitSshKey = resolveConfiguredGitSshKey(requireConfiguredSsh)
-    if (!gitSshKey) {
-        return undefined
-    }
-
-    return {
-        GIT_SSH_COMMAND: buildGitSshCommand(gitSshKey.privateKeyPath, {
-            hostKeyPolicy: sshHostKeyPolicy,
-        }),
-    }
-}
-
-async function runGitCommand(
-    args: string[],
-    options: GitRunOptions = {},
-): Promise<CommandResult> {
-    const env = buildGitEnv(
-        Boolean(options.requireConfiguredSsh),
-        options.sshHostKeyPolicy,
-    )
-
-    return await runCommand(
-        ['git', ...args],
-        {
-            ...options,
-            env: env ? env : undefined,
-        },
-    )
-}
-
-async function getRemoteUrlInternal(cwd: string, remote: string): Promise<string | null> {
-    const result = await runGitCommand(['remote', 'get-url', remote], { cwd, allowFailure: true })
-    if (result.exitCode !== 0) {
-        return null
-    }
-
-    return result.stdout.trim() || null
-}
-
-async function remoteRequiresConfiguredSsh(cwd: string, remote: string): Promise<boolean> {
-    const remoteUrl = await getRemoteUrlInternal(cwd, remote)
-    return Boolean(remoteUrl && isSshRemoteUrl(remoteUrl))
-}
-
-async function anyRemoteRequiresConfiguredSsh(cwd: string): Promise<boolean> {
-    const result = await runGitCommand(['remote'], { cwd, allowFailure: true })
-    if (result.exitCode !== 0) {
-        return false
-    }
-
-    const remotes = result.stdout
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .filter(Boolean)
-
-    for (const remote of remotes) {
-        if (await remoteRequiresConfiguredSsh(cwd, remote)) {
-            return true
-        }
-    }
-
-    return false
-}
-
-async function upstreamRequiresConfiguredSsh(cwd: string): Promise<boolean> {
-    const upstream = await getUpstreamBranch(cwd)
-    if (!upstream) {
-        return false
-    }
-
-    const separator = upstream.indexOf('/')
-    if (separator <= 0) {
-        return false
-    }
-
-    return await remoteRequiresConfiguredSsh(cwd, upstream.slice(0, separator))
-}
-
-export async function findRepositoryRoot(cwd: string): Promise<string | null> {
-    const result = await runGitCommand(['rev-parse', '--show-toplevel'], { cwd, allowFailure: true })
-    if (result.exitCode !== 0) {
-        return null
-    }
-
-    return result.stdout.trim() || null
-}
-
-export async function getRepositoryRoot(cwd: string): Promise<string> {
-    const repoRoot = await findRepositoryRoot(cwd)
-    if (!repoRoot) {
-        throw new Error(`Not a git repository: ${cwd}`)
-    }
-
-    return repoRoot
-}
-
-export async function assertGitRepository(cwd: string): Promise<void> {
-    try {
-        await runGitCommand(['rev-parse', '--is-inside-work-tree'], { cwd })
-    }
-    catch (error) {
-        if (error instanceof CommandError) {
-            throw new Error(`Not a git repository: ${cwd}`)
-        }
-        throw error
-    }
-}
-
-export async function cloneRepository(remoteUrl: string, targetDir: string): Promise<void> {
-    await runGitCommand(['clone', remoteUrl, targetDir], {
-        requireConfiguredSsh: isSshRemoteUrl(remoteUrl),
-        // Sync accepts first-seen SSH host keys automatically, but changed host keys still fail.
-        sshHostKeyPolicy: 'accept-new',
-    })
-}
-
-export async function getOriginUrl(cwd: string): Promise<string> {
-    const result = await runGitCommand(['remote', 'get-url', 'origin'], { cwd })
-    return result.stdout.trim()
-}
-
-export async function fetchOrigin(cwd: string): Promise<void> {
-    await runGitCommand(['fetch', 'origin', '--prune'], {
-        cwd,
-        requireConfiguredSsh: await remoteRequiresConfiguredSsh(cwd, 'origin'),
-        sshHostKeyPolicy: 'accept-new',
-    })
-}
-
-export async function fetchAllRemotes(cwd: string): Promise<void> {
-    await runGitCommand(['fetch', '--all', '--prune'], {
-        cwd,
-        requireConfiguredSsh: await anyRemoteRequiresConfiguredSsh(cwd),
-        sshHostKeyPolicy: 'accept-new',
-    })
-}
-
-export async function getWorktreeStatus(cwd: string): Promise<string> {
-    const result = await runGitCommand(['status', '--short'], { cwd })
-    return result.stdout.trim()
-}
-
-export async function isWorktreeDirty(cwd: string): Promise<boolean> {
-    return Boolean(await getWorktreeStatus(cwd))
-}
-
-export async function stageAll(cwd: string): Promise<void> {
-    await runGitCommand(['add', '-A'], { cwd })
-}
-
-export async function getCurrentBranch(cwd: string): Promise<string> {
-    try {
-        const result = await runGitCommand(['symbolic-ref', '--quiet', '--short', 'HEAD'], { cwd })
-        return result.stdout.trim()
-    }
-    catch (error) {
-        if (error instanceof CommandError) {
-            throw new Error('Detached HEAD; check out a branch before syncing or pushing.')
-        }
-        throw error
-    }
-}
-
-export async function getUpstreamBranch(cwd: string): Promise<string | null> {
-    const result = await runGitCommand(
-        ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
-        { cwd, allowFailure: true },
-    )
-
-    if (result.exitCode !== 0) {
-        return null
-    }
-
-    return result.stdout.trim() || null
-}
-
-export async function pullCurrentBranch(cwd: string): Promise<void> {
-    await runGitCommand(['pull', '--ff-only'], {
-        cwd,
-        requireConfiguredSsh: await upstreamRequiresConfiguredSsh(cwd),
-        sshHostKeyPolicy: 'accept-new',
-    })
-}
-
-export async function pullDefaultBranch(cwd: string, defaultBranch: string): Promise<void> {
-    await runGitCommand(['pull', '--ff-only', 'origin', defaultBranch], {
-        cwd,
-        requireConfiguredSsh: await remoteRequiresConfiguredSsh(cwd, 'origin'),
-        sshHostKeyPolicy: 'accept-new',
-    })
-}
-
-export async function getShortStatus(cwd: string): Promise<string> {
-    const result = await runGitCommand(['status', '--short'], { cwd })
-    return result.stdout
-}
-
-export function parseShortStatus(output: string): GitStatusEntry[] {
-    return output
-        .split(/\r?\n/)
-        .map(line => line.trimEnd())
-        .filter(Boolean)
-        .map((line) => {
-            const normalized = line.padEnd(3, ' ')
-            return {
-                index: normalized[0] ?? ' ',
-                worktree: normalized[1] ?? ' ',
-                path: normalized.slice(3).trim(),
-            }
-        })
-}
-
-export async function getStatusCounts(cwd: string): Promise<GitStatusCounts> {
-    const entries = parseShortStatus(await getShortStatus(cwd))
-    const counts: GitStatusCounts = {
-        staged: 0,
-        unstaged: 0,
-        untracked: 0,
-        total: entries.length,
-    }
-
-    for (const entry of entries) {
-        if (entry.index !== ' ' && entry.index !== '?') {
-            counts.staged += 1
-        }
-
-        if (entry.worktree !== ' ' && entry.worktree !== '?') {
-            counts.unstaged += 1
-        }
-
-        if (entry.index === '?' || entry.worktree === '?') {
-            counts.untracked += 1
-        }
-    }
-
-    return counts
-}
-
-export async function getStagedDiff(cwd: string): Promise<string> {
-    const result = await runGitCommand(['diff', '--cached'], { cwd })
-    return result.stdout
-}
-
-export async function getDiffAgainstHead(cwd: string): Promise<string> {
-    const result = await runGitCommand(['diff', 'HEAD', '--'], { cwd })
-    return result.stdout
-}
-
-export async function getRecentLog(cwd: string, count = 10): Promise<string> {
-    const result = await runGitCommand(['log', '--oneline', `-${count}`], { cwd, allowFailure: true })
-    return result.stdout
-}
-
-export async function getStagedFiles(cwd: string): Promise<string[]> {
-    const result = await runGitCommand(['diff', '--cached', '--name-only', '--diff-filter=ACMRTUXB'], { cwd })
-    return result.stdout
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .filter(Boolean)
-}
-
-export async function getChangedFilesAgainstHead(cwd: string): Promise<string[]> {
-    const result = await runGitCommand(['diff', '--name-only', 'HEAD', '--diff-filter=ACMRTUXB'], { cwd })
-    return result.stdout
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .filter(Boolean)
-}
-
-export async function getDiffStatAgainstHead(cwd: string): Promise<string> {
-    const result = await runGitCommand(['diff', '--stat', 'HEAD'], { cwd, allowFailure: true })
-    return result.stdout.trim()
-}
-
-export function buildFallbackCommitMessage(files: string[]): string {
-    if (files.length === 0) {
-        return 'Update repository files'
-    }
-
-    if (files.length === 1) {
-        return `Update ${basename(files[0]!) || files[0]}`
-    }
-
-    return `Update ${basename(files[0]!) || files[0]} and ${files.length - 1} other files`
-}
-
-export async function commitWithMessage(cwd: string, message: string): Promise<void> {
-    await runGitCommand(['commit', '-F', '-'], {
-        cwd,
-        input: message,
-    })
-}
-
-export async function pushBranch(cwd: string, branch: string, setUpstream: boolean): Promise<void> {
-    const args = setUpstream
-        ? ['push', '--set-upstream', 'origin', branch]
-        : ['push']
-    const requireConfiguredSsh = setUpstream
-        ? await remoteRequiresConfiguredSsh(cwd, 'origin')
-        : await upstreamRequiresConfiguredSsh(cwd)
-
-    await runGitCommand(args, {
-        cwd,
-        requireConfiguredSsh,
-    })
-}
-
-export async function getHeadShortSha(cwd: string): Promise<string> {
-    const result = await runGitCommand(['rev-parse', '--short', 'HEAD'], { cwd })
-    return result.stdout.trim()
-}
-
-export async function getHeadCommitHash(cwd: string): Promise<string> {
-    const result = await runGitCommand(['rev-parse', 'HEAD'], { cwd })
-    return result.stdout.trim()
-}
-
-export async function getHeadCommitMessage(cwd: string): Promise<string> {
-    const result = await runGitCommand(['log', '-1', '--pretty=%B'], { cwd })
-    return result.stdout.trim()
-}
-
-export async function getHeadShortMessage(cwd: string): Promise<string> {
-    const result = await runGitCommand(['log', '-1', '--pretty=%s'], { cwd })
-    return result.stdout.trim()
-}

package/src/ink/bark.tsx

@@ -1,241 +0,0 @@
-/** @jsxImportSource react */
-import { existsSync, mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import React, { useEffect, useMemo, useState } from 'react'
-import { Text } from 'ink'
-import barkAudioAssetPath from './assets/160092__jorickhoofd__dog-bark-1.mp3' with { type: 'file' }
-import { getBootstrapPixelRows } from '../ui.ts'
-import { AppFrame } from './components.tsx'
-import {
-    renderCommandScreen,
-    type CommandScreenController,
-} from './runtime.tsx'
-
-export const BARK_FRAME_DURATION_MS = 500
-export const BARK_FRAME_COUNT = 2
-export const BARK_ANIMATION_DURATION_MS = BARK_FRAME_DURATION_MS * BARK_FRAME_COUNT
-
-export const BARKING_PIXEL_ROWS = [
-  '3222222223344553222222233222',
-  '2223332224557888853233333222',
-  '2233433336688889a98534433222',
-  '2333433368877688aa9853433233',
-  '3333333499754477a89754333234',
-  '3433333685333455579755433344',
-  '3333324654136764238545643344',
-  '3333316443063136716542653334',
-  '3334214434671124964531554333',
-  '3334123235864246995431345443',
-  '3343112157743224786521335543',
-  '3452112245524023687520333543',
-  '3452111244424006276630323244',
-  '3342111354221000135420222344',
-  '3343143444411000036421223544',
-  '3444244511411223136322434544',
-  '4444444400221526155313245554',
-  '4443343421133546253553135555',
-  '44433344111218b9362991014555',
-  '3444333214113111627b41101355',
-  '333332111652233339c911111134',
-  '23342111169722236cb411111113',
-  '3333111117a51248ccb211111113',
-  '3333111129931117cc5111111113',
-  '333211112a9a2278971111111112',
-  '2231111119b912ab721111111102',
-  '2231111116b51299321111101101',
-  '2221111112721176111111101001',
-] as const
-
-
-const BARK_FRAME_ROWS = [
-    [...getBootstrapPixelRows()],
-    [...BARKING_PIXEL_ROWS],
-] as const
-
-export interface BarkAudioWriteResult {
-    directory: string
-    filePath: string
-}
-
-export interface BarkAudioPlaybackResult {
-    attempted: boolean
-}
-
-export interface BarkAudioPlaybackOptions {
-    silentBark?: boolean
-    env?: Record<string, string | undefined>
-    platform?: string
-    afplayPath?: string
-    audioPlayerExists?: (path: string) => boolean
-    writeAudioFile?: () => BarkAudioWriteResult | Promise<BarkAudioWriteResult>
-    spawnAudio?: (command: string[]) => { exited?: Promise<unknown> } | void
-}
-
-export interface BarkIntroSessionOptions {
-    commandTitle: string
-    enabled: boolean
-    silentBark?: boolean
-    env?: Record<string, string | undefined>
-    platform?: string
-    afplayPath?: string
-    renderIntro?: (
-        build: (controller: CommandScreenController<void>) => React.ReactElement,
-    ) => Promise<void>
-    playAudio?: (options: BarkAudioPlaybackOptions) => Promise<BarkAudioPlaybackResult>
-}
-
-export interface BarkIntroSession {
-    playOnce(): Promise<void>
-}
-
-export function getBarkFrameRows(): string[][] {
-    return BARK_FRAME_ROWS.map(frame => [...frame])
-}
-
-export function getBarkAnimationFrameIndex(elapsedMs: number): number {
-    const clamped = Math.max(0, Math.min(elapsedMs, BARK_ANIMATION_DURATION_MS - 1))
-    return Math.floor(clamped / BARK_FRAME_DURATION_MS)
-}
-
-export function shouldShowBarkIntro(options: {
-    json?: boolean
-    stdinIsTTY?: boolean
-    stdoutIsTTY?: boolean
-}): boolean {
-    return !options.json && Boolean(options.stdinIsTTY && options.stdoutIsTTY)
-}
-
-export function shouldPlayBarkAudio(options: {
-    silentBark?: boolean
-    env?: Record<string, string | undefined>
-    platform?: string
-    afplayPath?: string
-    audioPlayerExists?: (path: string) => boolean
-}): boolean {
-    if (options.silentBark || options.env?.TELA_SILENT_BARK === '1') {
-        return false
-    }
-
-    if ((options.platform ?? process.platform) !== 'darwin') {
-        return false
-    }
-
-    const afplayPath = options.afplayPath ?? '/usr/bin/afplay'
-    const audioPlayerExists = options.audioPlayerExists ?? existsSync
-    return audioPlayerExists(afplayPath)
-}
-
-export async function writeBarkAudioFile(baseDirectory = tmpdir()): Promise<BarkAudioWriteResult> {
-    const directory = mkdtempSync(join(baseDirectory, 'tela-bark-'))
-    const filePath = join(directory, 'bark.mp3')
-    await Bun.write(filePath, Bun.file(barkAudioAssetPath))
-    return { directory, filePath }
-}
-
-function spawnAudioCommand(command: string[]): { exited?: Promise<unknown> } {
-    const proc = Bun.spawn(command, {
-        stdin: 'ignore',
-        stdout: 'ignore',
-        stderr: 'ignore',
-    })
-
-    return { exited: proc.exited }
-}
-
-export async function playBarkAudio(options: BarkAudioPlaybackOptions = {}): Promise<BarkAudioPlaybackResult> {
-    if (!shouldPlayBarkAudio(options)) {
-        return { attempted: false }
-    }
-
-    const writeAudioFile = options.writeAudioFile ?? writeBarkAudioFile
-    const spawnAudio = options.spawnAudio ?? spawnAudioCommand
-    const afplayPath = options.afplayPath ?? '/usr/bin/afplay'
-    let audioFile: BarkAudioWriteResult | undefined
-
-    try {
-        audioFile = await writeAudioFile()
-        const writtenAudioFile = audioFile
-        const result = spawnAudio([afplayPath, writtenAudioFile.filePath])
-        void Promise.resolve(result?.exited)
-            .catch(() => {})
-            .finally(() => {
-                rmSync(writtenAudioFile.directory, { recursive: true, force: true })
-            })
-        return { attempted: true }
-    }
-    catch {
-        if (audioFile) {
-            rmSync(audioFile.directory, { recursive: true, force: true })
-        }
-        return { attempted: false }
-    }
-}
-
-export function createInkBarkSession(options: BarkIntroSessionOptions): BarkIntroSession {
-    let played = false
-
-    return {
-        async playOnce(): Promise<void> {
-            if (played || !options.enabled) {
-                return
-            }
-
-            played = true
-
-            const playAudio = options.playAudio ?? playBarkAudio
-            void playAudio({
-                silentBark: options.silentBark,
-                env: options.env,
-                platform: options.platform,
-                afplayPath: options.afplayPath,
-            }).catch(() => {})
-
-            const renderIntro = options.renderIntro ?? (async (build) => {
-                await renderCommandScreen<void>(build, { clearOnExit: true })
-            })
-
-            await renderIntro((controller) => React.createElement(BarkIntroScreen, {
-                controller,
-                title: options.commandTitle,
-            }))
-        },
-    }
-}
-
-export function BarkIntroScreen(props: {
-    controller: CommandScreenController<void>
-    title: string
-}): React.ReactElement {
-    const frames = useMemo(() => getBarkFrameRows(), [])
-    const [frameIndex, setFrameIndex] = useState(0)
-
-    useEffect(() => {
-        const interval = setInterval(() => {
-            setFrameIndex((current) => {
-                if (current >= frames.length - 1) {
-                    clearInterval(interval)
-                    props.controller.resolve(undefined, 20)
-                    return current
-                }
-
-                return current + 1
-            })
-        }, BARK_FRAME_DURATION_MS)
-
-        return () => {
-            clearInterval(interval)
-        }
-    }, [frames.length, props.controller])
-
-    return (
-        <AppFrame
-            title={props.title}
-            subtitle="Starting interactive command"
-            status="Bark intro"
-            mascotRows={frames[frameIndex]}
-        >
-            <Text dimColor>Preparing the workflow…</Text>
-        </AppFrame>
-    )
-}