@meistrari/tela-cli 0.1.0

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

@@ -0,0 +1,352 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react'
+import { Box, Text, useInput } from 'ink'
+import type { TelaCliConfig } from '../../types.ts'
+import {
+    AGENT_API_BROWSER_HELP,
+    AGENT_API_PRESET_OPTIONS,
+    inferAgentApiPreset,
+    resolveAgentApiUrlForPreset,
+} from '../../config.ts'
+import { AppFrame, Callout, KeyHints, Section, SelectList, SpinnerText, TextEntry } from '../components.tsx'
+import type { CommandScreenController } from '../runtime.tsx'
+
+export interface SetupScreenResult {
+    ok: true
+    config: TelaCliConfig
+    warnings: string[]
+    nextActions: string[]
+    checks: Array<{ label: string, status: string, detail: string }>
+}
+
+export interface SetupScreenProps {
+    controller: CommandScreenController<SetupScreenResult>
+    currentConfigSummary: string[]
+    defaults: {
+        agentApiUrl: string
+        cloneRoot: string
+        apiKey: string
+    }
+    hasExistingApiKey: boolean
+    validateAgentApiUrl: (value: string) => string | undefined
+    validateCloneRoot: (value: string) => string | undefined
+    validateApiKey: (value: string, existingApiKey?: string) => string | undefined
+    inspectCloneRoot: (path: string) => {
+        exists: boolean
+        isDirectory: boolean
+    }
+    execute: (input: {
+        agentApiUrl: string
+        cloneRoot: string
+        apiKey: string
+        createCloneRoot: boolean
+    }) => Promise<SetupScreenResult>
+}
+
+type SetupField = 'agentApiPreset' | 'agentApiUrl' | 'cloneRoot' | 'apiKey'
+type SetupPhase = 'editing' | 'review' | 'running' | 'done'
+
+function fieldLabel(field: SetupField): string {
+    switch (field) {
+        case 'agentApiPreset':
+            return 'Agent API target'
+        case 'agentApiUrl':
+            return 'Custom Agent API origin URL'
+        case 'cloneRoot':
+            return 'Clone root directory'
+        case 'apiKey':
+            return 'API key'
+    }
+}
+
+export function SetupScreen(props: SetupScreenProps): React.ReactElement {
+    const initialAgentApiPreset = useMemo(() => inferAgentApiPreset(props.defaults.agentApiUrl), [props.defaults.agentApiUrl])
+    const [phase, setPhase] = useState<SetupPhase>('editing')
+    const [fieldIndex, setFieldIndex] = useState(0)
+    const [values, setValues] = useState({
+        agentApiPreset: initialAgentApiPreset,
+        agentApiUrl: initialAgentApiPreset === 'custom' ? props.defaults.agentApiUrl : '',
+        cloneRoot: props.defaults.cloneRoot,
+        apiKey: '',
+    })
+    const [errors, setErrors] = useState<Partial<Record<SetupField, string>>>({})
+    const [createCloneRoot, setCreateCloneRoot] = useState(true)
+    const [result, setResult] = useState<SetupScreenResult | null>(null)
+    const startedRef = useRef(false)
+
+    const fieldOrder = useMemo(() => {
+        const order: SetupField[] = ['agentApiPreset']
+        if (values.agentApiPreset === 'custom') {
+            order.push('agentApiUrl')
+        }
+
+        order.push('cloneRoot', 'apiKey')
+        return order
+    }, [values.agentApiPreset])
+    const currentField = fieldOrder[fieldIndex]!
+    const cloneRootState = useMemo(() => props.inspectCloneRoot(values.cloneRoot), [props, values.cloneRoot])
+    const selectedPresetIndex = useMemo(
+        () => AGENT_API_PRESET_OPTIONS.findIndex(option => option.value === values.agentApiPreset),
+        [values.agentApiPreset],
+    )
+    const resolvedAgentApiUrl = useMemo(() => {
+        if (values.agentApiPreset === 'custom') {
+            return props.validateAgentApiUrl(values.agentApiUrl)
+                ? values.agentApiUrl || '<invalid custom origin>'
+                : values.agentApiUrl
+        }
+
+        try {
+            return resolveAgentApiUrlForPreset(values.agentApiPreset, values.agentApiUrl)
+        }
+        catch {
+            return values.agentApiUrl || '<invalid custom origin>'
+        }
+    }, [props, values.agentApiPreset, values.agentApiUrl])
+
+    useEffect(() => {
+        if (phase !== 'running' || startedRef.current) {
+            return
+        }
+
+        startedRef.current = true
+        void props.execute({
+            agentApiUrl: resolvedAgentApiUrl,
+            cloneRoot: values.cloneRoot,
+            apiKey: values.apiKey,
+            createCloneRoot,
+        })
+            .then((nextResult) => {
+                setResult(nextResult)
+                setPhase('done')
+            })
+            .catch((error) => {
+                props.controller.reject(error)
+            })
+    }, [createCloneRoot, phase, props, values])
+
+    useEffect(() => {
+        if (phase === 'done' && result) {
+            props.controller.resolve(result, 40)
+        }
+    }, [phase, props, result])
+
+    useInput((input, key) => {
+        if (phase === 'editing') {
+            if (key.escape) {
+                props.controller.reject(new Error('Setup cancelled.'))
+                return
+            }
+
+            if (currentField === 'agentApiPreset' && (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow)) {
+                const direction = (key.upArrow || key.leftArrow) ? -1 : 1
+                setValues(current => {
+                    const currentIndex = AGENT_API_PRESET_OPTIONS.findIndex(option => option.value === current.agentApiPreset)
+                    const nextIndex = (AGENT_API_PRESET_OPTIONS.length + currentIndex + direction) % AGENT_API_PRESET_OPTIONS.length
+                    const nextPreset = AGENT_API_PRESET_OPTIONS[nextIndex]?.value ?? current.agentApiPreset
+                    return {
+                        ...current,
+                        agentApiPreset: nextPreset,
+                    }
+                })
+                return
+            }
+
+            if ((key.backspace || key.delete) && currentField !== 'agentApiPreset') {
+                setValues(current => ({
+                    ...current,
+                    [currentField]: current[currentField].slice(0, -1),
+                }))
+                setErrors(current => ({
+                    ...current,
+                    [currentField]: undefined,
+                }))
+                return
+            }
+
+            if (key.return) {
+                const error = currentField === 'agentApiPreset'
+                    ? undefined
+                    : currentField === 'agentApiUrl'
+                    ? props.validateAgentApiUrl(values.agentApiUrl)
+                    : currentField === 'cloneRoot'
+                        ? props.validateCloneRoot(values.cloneRoot)
+                        : props.validateApiKey(values.apiKey, props.hasExistingApiKey ? props.defaults.apiKey : undefined)
+
+                if (error) {
+                    setErrors(current => ({
+                        ...current,
+                        [currentField]: error,
+                    }))
+                    return
+                }
+
+                if (fieldIndex === fieldOrder.length - 1) {
+                    setPhase('review')
+                    return
+                }
+
+                setFieldIndex(current => current + 1)
+                return
+            }
+
+            if (key.tab) {
+                setFieldIndex(current => (current + 1) % fieldOrder.length)
+                return
+            }
+
+            if (currentField === 'agentApiPreset') {
+                return
+            }
+
+            if (input) {
+                setValues(current => ({
+                    ...current,
+                    [currentField]: `${current[currentField]}${input}`,
+                }))
+                setErrors(current => ({
+                    ...current,
+                    [currentField]: undefined,
+                }))
+            }
+
+            return
+        }
+
+        if (phase === 'review') {
+            if (key.escape) {
+                setPhase('editing')
+                return
+            }
+
+            if (!cloneRootState.exists && (input === ' ' || key.leftArrow || key.rightArrow)) {
+                setCreateCloneRoot(current => !current)
+                return
+            }
+
+            if (key.return) {
+                setPhase('running')
+            }
+        }
+    })
+
+    return (
+        <AppFrame
+            title="Setup"
+            subtitle="Configure the local Tela environment with an Ink-driven wizard."
+            footer={
+                phase === 'editing'
+                    ? '↑/↓ choose target · Type to edit fields · Enter next · Tab switch field · Esc cancel'
+                    : phase === 'review'
+                        ? 'Enter save and run checks · Space toggle clone-root creation · Esc back'
+                        : undefined
+            }
+            status={phase === 'running' ? 'Saving config and running checks' : undefined}
+        >
+            {phase === 'editing' ? (
+                <>
+                    <Section title="Current config">
+                        {props.currentConfigSummary.map(line => (
+                            <Text key={line}>{line}</Text>
+                        ))}
+                    </Section>
+                    <Section title="Agent API target">
+                        <SelectList
+                            items={AGENT_API_PRESET_OPTIONS.map(option => ({
+                                key: option.value,
+                                label: option.label,
+                                hint: option.hint,
+                            }))}
+                            currentIndex={selectedPresetIndex}
+                        />
+                    </Section>
+                    <Callout tone="info">{AGENT_API_BROWSER_HELP}</Callout>
+                    <Section title="Fields">
+                        <Text>Resolved Agent API origin: {resolvedAgentApiUrl}</Text>
+                        {values.agentApiPreset === 'custom' ? (
+                            <Box marginTop={1}>
+                                <Text color={currentField === 'agentApiUrl' ? 'greenBright' : undefined}>
+                                    {currentField === 'agentApiUrl' ? '› ' : '  '}
+                                    Custom Agent API origin URL
+                                </Text>
+                                <TextEntry
+                                    label=""
+                                    value={values.agentApiUrl}
+                                    placeholder="https://agent-api.example.com"
+                                    error={currentField === 'agentApiUrl' ? errors.agentApiUrl : undefined}
+                                />
+                            </Box>
+                        ) : null}
+                        <TextEntry
+                            label={fieldLabel('cloneRoot')}
+                            value={values.cloneRoot}
+                            placeholder="/path/to/Code/Tela"
+                            error={currentField === 'cloneRoot' ? errors.cloneRoot : undefined}
+                        />
+                        <TextEntry
+                            label={fieldLabel('apiKey')}
+                            value={values.apiKey}
+                            placeholder={props.hasExistingApiKey ? 'Leave blank to keep the current API key' : 'Enter API key'}
+                            masked
+                            error={currentField === 'apiKey' ? errors.apiKey : undefined}
+                        />
+                    </Section>
+                    <KeyHints items={[
+                        `Active field: ${fieldLabel(currentField)}`,
+                        `Target: ${AGENT_API_PRESET_OPTIONS[selectedPresetIndex]?.label ?? 'Custom'}`,
+                    ]} />
+                </>
+            ) : null}
+
+            {phase === 'review' ? (
+                <>
+                    <Section title="Review">
+                        <Text>Agent API target: {AGENT_API_PRESET_OPTIONS[selectedPresetIndex]?.label ?? 'Custom'}</Text>
+                        <Text>Agent API origin: {resolvedAgentApiUrl}</Text>
+                        <Text>Clone root: {values.cloneRoot}</Text>
+                        <Text>API key: {values.apiKey ? '*'.repeat(values.apiKey.length) : (props.hasExistingApiKey ? '<keep existing>' : '<missing>')}</Text>
+                        <Text>Clone root state: {cloneRootState.exists ? (cloneRootState.isDirectory ? 'existing directory' : 'existing non-directory path') : 'missing'}</Text>
+                        {!cloneRootState.exists ? (
+                            <Text>Create clone root if missing: {createCloneRoot ? 'yes' : 'no'}</Text>
+                        ) : null}
+                    </Section>
+                    <Callout tone="info">{AGENT_API_BROWSER_HELP}</Callout>
+                    {!cloneRootState.exists ? (
+                        <Callout tone="info">
+                            Toggle clone-root creation before saving if you want setup to leave the path untouched.
+                        </Callout>
+                    ) : null}
+                </>
+            ) : null}
+
+            {phase === 'running' ? (
+                <Section title="Running">
+                    <SpinnerText label="Persisting configuration and checking local dependencies" />
+                </Section>
+            ) : null}
+
+            {phase === 'done' && result ? (
+                <>
+                    <Section title="Saved config">
+                        <Text>Agent API origin: {result.config.agentApiUrl}</Text>
+                        <Text>Clone root: {result.config.cloneRoot}</Text>
+                    </Section>
+                    <Callout tone="info">{AGENT_API_BROWSER_HELP}</Callout>
+                    <Section title="Checks">
+                        {result.checks.map(check => (
+                            <Text key={check.label}>{`${check.label}: ${check.status} — ${check.detail}`}</Text>
+                        ))}
+                    </Section>
+                    {result.warnings.length > 0 ? (
+                        <Section title="Warnings">
+                            {result.warnings.map(warning => (
+                                <Text key={warning} color="yellow">{warning}</Text>
+                            ))}
+                        </Section>
+                    ) : (
+                        <Callout tone="success">Setup checks completed successfully.</Callout>
+                    )}
+                </>
+            ) : null}
+        </AppFrame>
+    )
+}

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

@@ -0,0 +1,282 @@
+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>
+    )
+}