@meistrari/tela-cli 0.6.0 → 0.7.4

package/src/ink/screens/sync-screen.tsx

@@ -1,282 +0,0 @@
-import React, { useEffect, useMemo, useRef, useState } from 'react'
-import { Box, Text, useInput } from 'ink'
-import type { BatchSyncFailure, SyncResult } from '../../types.ts'
-import { AppFrame, Callout, KeyHints, Section, SelectList, SpinnerText, TextEntry } from '../components.tsx'
-import type { CommandScreenController } from '../runtime.tsx'
-
-export interface SyncScreenResult {
-    ok: boolean
-    mode: 'current' | 'repository' | 'all'
-    successes: SyncResult[]
-    failures: BatchSyncFailure[]
-    nextActions: string[]
-}
-
-export interface SyncProgressItem {
-    id: string
-    label: string
-    status: 'pending' | 'running' | 'success' | 'failure'
-    detail?: string
-}
-
-export interface SyncScreenProps {
-    controller: CommandScreenController<SyncScreenResult>
-    mode: 'current' | 'repository' | 'all'
-    dryRun?: boolean
-    targetLabel: string
-    cloneRoot?: string
-    initialRepository?: string
-    availableRepositories?: string[]
-    execute: (
-        repository: string | undefined,
-        onProgress: (update: SyncProgressItem) => void,
-    ) => Promise<SyncScreenResult>
-}
-
-type SyncPhase = 'pick' | 'manual' | 'preview' | 'running' | 'done'
-
-const MANUAL_ENTRY_VALUE = '__manual__'
-
-export function SyncScreen(props: SyncScreenProps): React.ReactElement {
-    const [phase, setPhase] = useState<SyncPhase>(() => {
-        if (props.mode === 'repository' && !props.initialRepository) {
-            return props.availableRepositories && props.availableRepositories.length > 0 ? 'pick' : 'manual'
-        }
-
-        return 'preview'
-    })
-    const [repository, setRepository] = useState(props.initialRepository ?? '')
-    const [manualRepository, setManualRepository] = useState('')
-    const [currentIndex, setCurrentIndex] = useState(0)
-    const [result, setResult] = useState<SyncScreenResult | null>(null)
-    const [progressItems, setProgressItems] = useState<SyncProgressItem[]>(() => {
-        if (props.mode === 'all' && props.availableRepositories) {
-            return props.availableRepositories.map(repo => ({
-                id: repo,
-                label: repo,
-                status: 'pending',
-            }))
-        }
-
-        return []
-    })
-    const startedRef = useRef(false)
-
-    const selectableRepositories = useMemo(() => {
-        return [
-            ...(props.availableRepositories ?? []).map(repo => ({
-                key: repo,
-                label: repo,
-            })),
-            { key: MANUAL_ENTRY_VALUE, label: 'Enter a repository name manually' },
-        ]
-    }, [props.availableRepositories])
-
-    useEffect(() => {
-        if (phase !== 'running' || startedRef.current) {
-            return
-        }
-
-        startedRef.current = true
-        void props.execute(
-            repository || undefined,
-            (update) => {
-                setProgressItems(current => {
-                    const existingIndex = current.findIndex(item => item.id === update.id)
-                    if (existingIndex === -1) {
-                        return [...current, update]
-                    }
-
-                    return current.map(item => item.id === update.id ? update : item)
-                })
-            },
-        )
-            .then((nextResult) => {
-                setResult(nextResult)
-                setPhase('done')
-            })
-            .catch((error) => {
-                props.controller.reject(error)
-            })
-    }, [phase, props, repository])
-
-    useEffect(() => {
-        if (phase === 'done' && result) {
-            props.controller.resolve(result, 40)
-        }
-    }, [phase, props, result])
-
-    useInput((input, key) => {
-        if (phase === 'pick') {
-            if (key.downArrow || input === 'j') {
-                setCurrentIndex(current => Math.min(current + 1, selectableRepositories.length - 1))
-                return
-            }
-
-            if (key.upArrow || input === 'k') {
-                setCurrentIndex(current => Math.max(current - 1, 0))
-                return
-            }
-
-            if (key.escape) {
-                props.controller.reject(new Error('Sync cancelled.'))
-                return
-            }
-
-            if (key.return) {
-                const selected = selectableRepositories[currentIndex]?.key
-                if (selected === MANUAL_ENTRY_VALUE) {
-                    setPhase('manual')
-                    return
-                }
-
-                setRepository(String(selected ?? ''))
-                setPhase('preview')
-            }
-
-            return
-        }
-
-        if (phase === 'manual') {
-            if (key.escape) {
-                props.controller.reject(new Error('Sync cancelled.'))
-                return
-            }
-
-            if (key.backspace || key.delete) {
-                setManualRepository(current => current.slice(0, -1))
-                return
-            }
-
-            if (key.return) {
-                if (!manualRepository.trim()) {
-                    props.controller.reject(new Error('Repository name is required when not running inside a git repository.'))
-                    return
-                }
-
-                setRepository(manualRepository.trim())
-                setPhase('preview')
-                return
-            }
-
-            if (input) {
-                setManualRepository(current => `${current}${input}`)
-            }
-            return
-        }
-
-        if (phase === 'preview') {
-            if (key.escape) {
-                props.controller.reject(new Error('Sync cancelled.'))
-                return
-            }
-
-            if (key.return) {
-                if (props.dryRun) {
-                    setResult({
-                        ok: true,
-                        mode: props.mode,
-                        successes: [],
-                        failures: [],
-                        nextActions: [
-                            props.mode === 'current'
-                                ? 'Run `tela sync --current` without `--dry-run` to update this checkout.'
-                                : props.mode === 'all'
-                                    ? 'Run `tela sync --all` without `--dry-run` to refresh all repositories.'
-                                    : `Run \`tela sync ${repository}\` without \`--dry-run\` to clone or update the repository.`,
-                        ],
-                    })
-                    setPhase('done')
-                    return
-                }
-
-                setPhase('running')
-            }
-        }
-    })
-
-    return (
-        <AppFrame
-            title="Sync"
-            subtitle="Refresh the current checkout, a named repository, or the whole clone root."
-            footer={
-                phase === 'pick'
-                    ? '↑/↓ move · Enter select · Esc cancel'
-                    : phase === 'manual'
-                        ? 'Type repository name · Enter continue · Esc cancel'
-                        : phase === 'preview'
-                            ? 'Enter run · Esc cancel'
-                            : undefined
-            }
-            status={phase === 'running' ? 'Sync in progress' : undefined}
-        >
-            {phase === 'pick' ? (
-                <>
-                    <Section title="Repository picker">
-                        <SelectList items={selectableRepositories} currentIndex={currentIndex} />
-                    </Section>
-                    <KeyHints items={['Select a repository from the clone root or switch to manual entry']} />
-                </>
-            ) : null}
-
-            {phase === 'manual' ? (
-                <Section title="Repository name">
-                    <TextEntry label="Repository" value={manualRepository} placeholder="agent-api" />
-                </Section>
-            ) : null}
-
-            {phase === 'preview' ? (
-                <>
-                    <Section title={props.dryRun ? 'Dry run' : 'Plan'}>
-                        <Text>Mode: {props.mode}</Text>
-                        <Text>Target: {props.mode === 'repository' ? repository : props.targetLabel}</Text>
-                        {props.cloneRoot ? <Text>Clone root: {props.cloneRoot}</Text> : null}
-                    </Section>
-                    {props.availableRepositories && props.mode === 'all' ? (
-                        <Section title="Repositories">
-                            {props.availableRepositories.map(repo => (
-                                <Text key={repo}>{repo}</Text>
-                            ))}
-                        </Section>
-                    ) : null}
-                </>
-            ) : null}
-
-            {phase === 'running' ? (
-                <>
-                    <SpinnerText label={`Syncing ${props.mode === 'repository' ? repository : props.targetLabel}`} />
-                    {progressItems.length > 0 ? (
-                        <Section title="Progress">
-                            {progressItems.map(item => (
-                                <Text key={item.id}>
-                                    {`${item.label}: ${item.status}${item.detail ? ` — ${item.detail}` : ''}`}
-                                </Text>
-                            ))}
-                        </Section>
-                    ) : null}
-                </>
-            ) : null}
-
-            {phase === 'done' && result ? (
-                <>
-                    <Section title="Result">
-                        <Text>Mode: {result.mode}</Text>
-                        <Text>Successes: {result.successes.length}</Text>
-                        <Text>Failures: {result.failures.length}</Text>
-                    </Section>
-                    {result.failures.length > 0 ? (
-                        <Section title="Failures">
-                            {result.failures.map(failure => (
-                                <Text key={failure.targetDir} color="yellow">
-                                    {`${failure.targetDir}: ${failure.error}`}
-                                </Text>
-                            ))}
-                        </Section>
-                    ) : (
-                        <Callout tone="success">Sync finished successfully.</Callout>
-                    )}
-                </>
-            ) : null}
-        </AppFrame>
-    )
-}

package/src/process.ts

@@ -1,251 +0,0 @@
-export interface CommandResult {
-    command: string[]
-    exitCode: number
-    stdout: string
-    stderr: string
-}
-
-export interface RunCommandOptions {
-    cwd?: string
-    env?: Record<string, string | undefined>
-    stdin?: 'pipe' | 'inherit' | 'ignore'
-    input?: string
-    allowFailure?: boolean
-}
-
-export interface RunStreamingCommandOptions extends RunCommandOptions {
-    onStdoutLine?: (line: string) => void | Promise<void>
-    onStderrLine?: (line: string) => void | Promise<void>
-}
-
-export interface StreamingCommandHandle {
-    result: Promise<CommandResult>
-    interrupt(): void
-    kill(): void
-}
-
-export class CommandError extends Error {
-    constructor(
-        message: string,
-        public readonly result: CommandResult,
-    ) {
-        super(message)
-    }
-}
-
-async function readStream(stream: ReadableStream<Uint8Array> | null | undefined): Promise<string> {
-    if (!stream) {
-        return ''
-    }
-
-    return await new Response(stream).text()
-}
-
-async function readLineStream(
-    stream: ReadableStream<Uint8Array> | null | undefined,
-    onLine?: (line: string) => void | Promise<void>,
-): Promise<string> {
-    if (!stream) {
-        return ''
-    }
-
-    const reader = stream.getReader()
-    const decoder = new TextDecoder()
-    let buffer = ''
-    let output = ''
-
-    while (true) {
-        const { done, value } = await reader.read()
-        if (done) {
-            break
-        }
-
-        const chunk = decoder.decode(value, { stream: true })
-        output += chunk
-        buffer += chunk
-
-        let newlineIndex = buffer.indexOf('\n')
-        while (newlineIndex >= 0) {
-            const line = buffer.slice(0, newlineIndex).replace(/\r$/, '')
-            if (onLine) {
-                await onLine(line)
-            }
-            buffer = buffer.slice(newlineIndex + 1)
-            newlineIndex = buffer.indexOf('\n')
-        }
-    }
-
-    const remainder = decoder.decode()
-    if (remainder) {
-        output += remainder
-        buffer += remainder
-    }
-
-    if (buffer.length > 0 && onLine) {
-        await onLine(buffer.replace(/\r$/, ''))
-    }
-
-    return output
-}
-
-export async function runCommand(
-    command: string[],
-    options: RunCommandOptions = {},
-): Promise<CommandResult> {
-    const stdin = options.input !== undefined
-        ? new Blob([options.input])
-        : (options.stdin ?? 'pipe')
-
-    const proc = Bun.spawn(command, {
-        cwd: options.cwd,
-        env: options.env ? { ...process.env, ...options.env } : process.env,
-        stdin,
-        stdout: 'pipe',
-        stderr: 'pipe',
-    })
-
-    const [stdout, stderr, exitCode] = await Promise.all([
-        readStream(proc.stdout),
-        readStream(proc.stderr),
-        proc.exited,
-    ])
-
-    const result: CommandResult = {
-        command,
-        exitCode: exitCode ?? 1,
-        stdout,
-        stderr,
-    }
-
-    if (result.exitCode !== 0 && !options.allowFailure) {
-        throw new CommandError(
-            `Command failed (${result.exitCode}): ${command.join(' ')}`,
-            result,
-        )
-    }
-
-    return result
-}
-
-export async function runShell(
-    script: string,
-    options: Omit<RunCommandOptions, 'input'> = {},
-): Promise<CommandResult> {
-    return await runCommand(
-        ['/bin/bash', '-lc', script],
-        options,
-    )
-}
-
-export async function commandExists(command: string): Promise<boolean> {
-    const result = await runCommand(['which', command], { allowFailure: true })
-    return result.exitCode === 0
-}
-
-export async function runInteractiveCommand(
-    command: string[],
-    options: Omit<RunCommandOptions, 'stdin' | 'input'> = {},
-): Promise<CommandResult> {
-    const proc = Bun.spawn(command, {
-        cwd: options.cwd,
-        env: options.env ? { ...process.env, ...options.env } : process.env,
-        stdin: 'inherit',
-        stdout: 'inherit',
-        stderr: 'inherit',
-    })
-
-    const exitCode = await proc.exited
-    const result: CommandResult = {
-        command,
-        exitCode: exitCode ?? 1,
-        stdout: '',
-        stderr: '',
-    }
-
-    if (result.exitCode !== 0 && !options.allowFailure) {
-        throw new CommandError(
-            `Command failed (${result.exitCode}): ${command.join(' ')}`,
-            result,
-        )
-    }
-
-    return result
-}
-
-export async function runStreamingCommand(
-    command: string[],
-    options: RunStreamingCommandOptions = {},
-): Promise<CommandResult> {
-    return await spawnStreamingCommand(command, options).result
-}
-
-export function spawnStreamingCommand(
-    command: string[],
-    options: RunStreamingCommandOptions = {},
-): StreamingCommandHandle {
-    const stdin = options.input !== undefined
-        ? new Blob([options.input])
-        : (options.stdin ?? 'pipe')
-
-    const proc = Bun.spawn(command, {
-        cwd: options.cwd,
-        env: options.env ? { ...process.env, ...options.env } : process.env,
-        stdin,
-        stdout: 'pipe',
-        stderr: 'pipe',
-    })
-
-    const sendSignal = (signal?: string) => {
-        try {
-            ;(proc as { kill: (signal?: string) => void }).kill(signal)
-        }
-        catch {
-            try {
-                proc.kill()
-            }
-            catch {
-                // Best-effort shutdown only.
-            }
-        }
-    }
-
-    const result = (async () => {
-        try {
-            const [stdout, stderr, exitCode] = await Promise.all([
-                readLineStream(proc.stdout, options.onStdoutLine),
-                readLineStream(proc.stderr, options.onStderrLine),
-                proc.exited,
-            ])
-
-            const commandResult: CommandResult = {
-                command,
-                exitCode: exitCode ?? 1,
-                stdout,
-                stderr,
-            }
-
-            if (commandResult.exitCode !== 0 && !options.allowFailure) {
-                throw new CommandError(
-                    `Command failed (${commandResult.exitCode}): ${command.join(' ')}`,
-                    commandResult,
-                )
-            }
-
-            return commandResult
-        }
-        catch (error) {
-            sendSignal()
-            throw error
-        }
-    })()
-
-    return {
-        result,
-        interrupt() {
-            sendSignal('SIGINT')
-        },
-        kill() {
-            sendSignal('SIGKILL')
-        },
-    }
-}