@meistrari/tela-cli 0.1.0

package/src/git.ts

@@ -0,0 +1,250 @@
+import { basename } from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { CommandError, runCommand, runShell } from './process.ts'
+
+export interface GitStatusEntry {
+    index: string
+    worktree: string
+    path: string
+}
+
+export interface GitStatusCounts {
+    staged: number
+    unstaged: number
+    untracked: number
+    total: number
+}
+
+export async function findRepositoryRoot(cwd: string): Promise<string | null> {
+    const result = await runCommand(['git', '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 runCommand(['git', '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 runCommand(['git', 'clone', remoteUrl, targetDir])
+}
+
+export async function getOriginUrl(cwd: string): Promise<string> {
+    const result = await runCommand(['git', 'remote', 'get-url', 'origin'], { cwd })
+    return result.stdout.trim()
+}
+
+export async function fetchOrigin(cwd: string): Promise<void> {
+    await runCommand(['git', 'fetch', 'origin', '--prune'], { cwd })
+}
+
+export async function fetchAllRemotes(cwd: string): Promise<void> {
+    await runCommand(['git', 'fetch', '--all', '--prune'], { cwd })
+}
+
+export async function getWorktreeStatus(cwd: string): Promise<string> {
+    const result = await runCommand(['git', '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 runCommand(['git', 'add', '-A'], { cwd })
+}
+
+export async function getCurrentBranch(cwd: string): Promise<string> {
+    try {
+        const result = await runCommand(['git', '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 runCommand(
+        ['git', '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 runCommand(['git', 'pull', '--ff-only'], { cwd })
+}
+
+export async function pullDefaultBranch(cwd: string, defaultBranch: string): Promise<void> {
+    await runCommand(['git', 'pull', '--ff-only', 'origin', defaultBranch], { cwd })
+}
+
+export async function getShortStatus(cwd: string): Promise<string> {
+    const result = await runCommand(['git', '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 runCommand(['git', 'diff', '--cached'], { cwd })
+    return result.stdout
+}
+
+export async function getDiffAgainstHead(cwd: string): Promise<string> {
+    const result = await runCommand(['git', 'diff', 'HEAD', '--'], { cwd })
+    return result.stdout
+}
+
+export async function getRecentLog(cwd: string, count = 10): Promise<string> {
+    const result = await runCommand(['git', 'log', '--oneline', `-${count}`], { cwd, allowFailure: true })
+    return result.stdout
+}
+
+export async function getStagedFiles(cwd: string): Promise<string[]> {
+    const result = await runCommand(['git', '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 runCommand(['git', '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 runCommand(['git', '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`
+}
+
+function buildCommitDelimiter(message: string): string {
+    let delimiter = `__TELA_COMMIT_${randomUUID().replace(/-/g, '_')}__`
+    while (message.includes(delimiter)) {
+        delimiter = `__TELA_COMMIT_${randomUUID().replace(/-/g, '_')}__`
+    }
+    return delimiter
+}
+
+export async function commitWithMessage(cwd: string, message: string): Promise<void> {
+    const delimiter = buildCommitDelimiter(message)
+    const script = [
+        'git commit -F - <<\'__TELA_COMMIT__\'',
+        message,
+        '__TELA_COMMIT__',
+    ].join('\n').replaceAll('__TELA_COMMIT__', delimiter)
+
+    await runShell(script, { cwd })
+}
+
+export async function pushBranch(cwd: string, branch: string, setUpstream: boolean): Promise<void> {
+    const args = setUpstream
+        ? ['git', 'push', '--set-upstream', 'origin', branch]
+        : ['git', 'push']
+    await runCommand(args, { cwd })
+}
+
+export async function getHeadShortSha(cwd: string): Promise<string> {
+    const result = await runCommand(['git', 'rev-parse', '--short', 'HEAD'], { cwd })
+    return result.stdout.trim()
+}
+
+export async function getHeadCommitHash(cwd: string): Promise<string> {
+    const result = await runCommand(['git', 'rev-parse', 'HEAD'], { cwd })
+    return result.stdout.trim()
+}
+
+export async function getHeadCommitMessage(cwd: string): Promise<string> {
+    const result = await runCommand(['git', 'log', '-1', '--pretty=%B'], { cwd })
+    return result.stdout.trim()
+}
+
+export async function getHeadShortMessage(cwd: string): Promise<string> {
+    const result = await runCommand(['git', 'log', '-1', '--pretty=%s'], { cwd })
+    return result.stdout.trim()
+}

package/src/ink/bark.tsx

@@ -0,0 +1,288 @@
+import { existsSync, mkdtempSync, rmSync, writeFileSync } 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 { 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
+
+function pseudoNoise(seed: number): number {
+    const raw = Math.sin((seed + 1) * 12.9898) * 43758.5453
+    return (raw - Math.floor(raw)) * 2 - 1
+}
+
+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
+    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 function buildBarkWavBuffer(): Uint8Array {
+    const sampleRate = 22_050
+    const durationSeconds = 0.18
+    const sampleCount = Math.floor(sampleRate * durationSeconds)
+    const pcm = new Int16Array(sampleCount)
+
+    for (let index = 0; index < sampleCount; index += 1) {
+        const t = index / sampleRate
+        const attack = Math.min(1, t * 40)
+        const decay = Math.exp(-15 * t)
+        const envelope = attack * decay
+        const pitch = 760 - (420 * t)
+        const body = Math.sin((2 * Math.PI * pitch) * t) * 0.58
+        const growl = Math.sin((2 * Math.PI * (pitch * 0.47)) * t + 0.8) * 0.22
+        const snap = pseudoNoise(index) * (t < 0.035 ? 0.28 : 0.08)
+        const sample = Math.max(-1, Math.min(1, (body + growl + snap) * envelope))
+        pcm[index] = Math.round(sample * 0x7fff)
+    }
+
+    const dataSize = pcm.byteLength
+    const buffer = new ArrayBuffer(44 + dataSize)
+    const view = new DataView(buffer)
+    const bytes = new Uint8Array(buffer)
+
+    const writeString = (offset: number, value: string) => {
+        for (let index = 0; index < value.length; index += 1) {
+            view.setUint8(offset + index, value.charCodeAt(index))
+        }
+    }
+
+    writeString(0, 'RIFF')
+    view.setUint32(4, 36 + dataSize, true)
+    writeString(8, 'WAVE')
+    writeString(12, 'fmt ')
+    view.setUint32(16, 16, true)
+    view.setUint16(20, 1, true)
+    view.setUint16(22, 1, true)
+    view.setUint32(24, sampleRate, true)
+    view.setUint32(28, sampleRate * 2, true)
+    view.setUint16(32, 2, true)
+    view.setUint16(34, 16, true)
+    writeString(36, 'data')
+    view.setUint32(40, dataSize, true)
+    bytes.set(new Uint8Array(pcm.buffer), 44)
+
+    return bytes
+}
+
+export function writeBarkAudioFile(baseDirectory = tmpdir()): BarkAudioWriteResult {
+    const directory = mkdtempSync(join(baseDirectory, 'tela-bark-'))
+    const filePath = join(directory, 'bark.wav')
+    writeFileSync(filePath, buildBarkWavBuffer())
+    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'
+    const audioFile = writeAudioFile()
+
+    try {
+        const result = spawnAudio([afplayPath, audioFile.filePath])
+        void Promise.resolve(result?.exited)
+            .catch(() => {})
+            .finally(() => {
+                rmSync(audioFile.directory, { recursive: true, force: true })
+            })
+        return { attempted: true }
+    }
+    catch {
+        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>
+    )
+}