@meistrari/tela-cli 0.1.0

package/src/runtime.ts

@@ -0,0 +1,147 @@
+import { createUserFacingError, toUserFacingError, type UserFacingError } from './errors.ts'
+
+export interface RuntimePromptModule {
+    note?: (message: string, title?: string) => void
+    intro?: (message: string) => void
+    outro?: (message: string) => void
+    cancel?: (message: string) => void
+    log?: {
+        success?: (message: string) => void
+        error?: (message: string) => void
+    }
+}
+
+export interface RuntimeOptions {
+    json?: boolean
+    verbose?: boolean
+    decorate?: boolean
+    prompts?: RuntimePromptModule
+    writeStdout?: (message: string) => void
+    writeStderr?: (message: string) => void
+}
+
+export interface StepRecord {
+    label: string
+    status: 'success' | 'failed'
+    detail?: string
+}
+
+export class CommandRuntime {
+    public readonly json: boolean
+    public readonly verbose: boolean
+    public readonly decorate: boolean
+    public readonly prompts?: RuntimePromptModule
+    private readonly writeStdout?: (message: string) => void
+    private readonly writeStderr?: (message: string) => void
+    private readonly steps: StepRecord[] = []
+
+    constructor(options: RuntimeOptions = {}) {
+        this.json = options.json ?? false
+        this.verbose = options.verbose ?? false
+        this.decorate = options.decorate ?? (!this.json && Boolean(process.stdout.isTTY))
+        this.prompts = options.prompts
+        this.writeStdout = options.writeStdout
+        this.writeStderr = options.writeStderr
+    }
+
+    emit(message: string): void {
+        if (this.json) {
+            return
+        }
+
+        if (this.writeStdout) {
+            this.writeStdout(message)
+            return
+        }
+
+        if (this.prompts?.note) {
+            this.prompts.note(message)
+            return
+        }
+
+        console.log(message)
+    }
+
+    emitJson(payload: unknown): void {
+        const message = `${JSON.stringify(payload, null, 2)}\n`
+
+        if (this.writeStdout) {
+            this.writeStdout(message)
+            return
+        }
+
+        process.stdout.write(message)
+    }
+
+    emitError(message: string): void {
+        if (this.writeStderr) {
+            this.writeStderr(message)
+            return
+        }
+
+        if (this.prompts?.note) {
+            this.prompts.note(message)
+            return
+        }
+
+        console.error(message)
+    }
+
+    emitSuccess(message: string): void {
+        if (this.json) {
+            return
+        }
+
+        if (this.prompts?.log?.success) {
+            this.prompts.log.success(message)
+            return
+        }
+
+        this.emit(message)
+    }
+
+    async runStep<T>(
+        label: string,
+        fn: () => Promise<T>,
+        detail?: (value: T) => string | undefined,
+    ): Promise<T> {
+        try {
+            const value = await fn()
+            this.steps.push({
+                label,
+                status: 'success',
+                detail: detail?.(value),
+            })
+            return value
+        }
+        catch (error) {
+            const userError = toUserFacingError(error)
+            this.steps.push({
+                label,
+                status: 'failed',
+                detail: userError.summary,
+            })
+            throw error
+        }
+    }
+
+    getStepRecords(): StepRecord[] {
+        return [...this.steps]
+    }
+
+    appendEvidence(error: UserFacingError, evidence: string[]): UserFacingError {
+        if (evidence.length === 0) {
+            return error
+        }
+
+        return createUserFacingError({
+            code: error.code,
+            summary: error.summary,
+            details: error.details,
+            fixes: error.fixes,
+            evidence: [...error.evidence, ...evidence],
+            exitCode: error.exitCode,
+            cause: error.cause,
+        })
+    }
+}

package/src/types.ts

@@ -0,0 +1,80 @@
+export interface TelaCliConfig {
+    agentApiUrl: string
+    cloneRoot: string
+    apiKey: string
+}
+
+export interface OrganizationSummary {
+    id: string
+    workspaceId: string
+    name: string
+}
+
+export interface AgentRepoSummary {
+    id: string
+    workspaceId: string
+    organizationId: string
+    repository: string
+}
+
+export interface ForgejoRepositorySummary {
+    id: number
+    name: string
+    fullName: string
+    ownerLogin: string
+    htmlUrl: string
+    cloneUrl: string
+    sshUrl: string
+    defaultBranch: string | null
+    private: boolean
+}
+
+export interface RepositoryLookupResponse {
+    success: boolean
+    organization?: OrganizationSummary
+    agentRepo?: AgentRepoSummary
+    forgejoRepository?: ForgejoRepositorySummary
+    error?: string
+}
+
+export type AgentFeedbackStatus = 'success' | 'failed'
+
+export interface AgentFeedbackItem {
+    status: AgentFeedbackStatus
+    reason: string
+    suggestion: string
+}
+
+export interface AgentFeedbackListResponse {
+    commitHash: string
+    feedbacks: AgentFeedbackItem[]
+}
+
+export interface SyncResult {
+    targetDir: string
+    branch: string
+    head: string
+    cloned: boolean
+}
+
+export interface BatchSyncFailure {
+    targetDir: string
+    error: string
+    category?: string
+}
+
+export interface BatchSyncResult {
+    successes: SyncResult[]
+    failures: BatchSyncFailure[]
+}
+
+export interface PushResult {
+    repoRoot: string
+    branch: string
+    message: string
+    retriedCommit: boolean
+    commitSha: string
+    upstream: string | null
+    messageSource: 'manual' | 'claude' | 'fallback'
+    fallbackReason?: string
+}

package/src/ui.ts

@@ -0,0 +1,297 @@
+export interface RenderOptions {
+    decorate?: boolean
+}
+
+const BOOTSTRAP_PIXEL_ROWS = [
+    '2222222222233443222222233222',
+    '2223332223556777743233333222',
+    '2233433335788789986434433222',
+    '2333433347888889988743433233',
+    '3333333368777778987554333234',
+    '3433332488755567887415433344',
+    '3333321476543456776512643344',
+    '3333311355433445666421553334',
+    '3334313453222554774211454333',
+    '3334213323223534664212334443',
+    '3343111125223327113202333443',
+    '3453121136444346345302333343',
+    '3453131146568422244401222354',
+    '3342142354345742244202222444',
+    '3344343554444764553213324545',
+    '3445444514535655543213555544',
+    '4444443410135566532131455554',
+    '4443343321123454312640255555',
+    '444333431111123214a910035555',
+    '34443331132111017bc401102465',
+    '3333320006742139cd9111110135',
+    '23342010169733addc5111111014',
+    '3333111017a3013cda2111111113',
+    '3333111029831217d51111111103',
+    '333200102a9a218a711111111102',
+    '2231011019c911bc411111110102',
+    '2231001105c411aa111111100101',
+    '2221001112821175111110000000',
+] as const
+
+const TELA_ASCII_HEADER = [
+    '███████████╗  ████████╗███████╗██╗      █████╗ ',
+    '██       ██║  ╚══██╔══╝██╔════╝██║     ██╔══██╗',
+    '██       ██║     ██║   █████╗  ██║     ███████║',
+    '██       ██║     ██║   ██╔══╝  ██║     ██╔══██║',
+    '██       ██║     ██║   ███████╗███████╗██║  ██║',
+    '╚██████████╝     ╚═╝   ╚══════╝╚══════╝╚═╝  ╚═╝',
+] as const
+
+const ASCII_PIXEL_RAMP = ' .,:-=+*#%@'
+
+function isDecorated(options: RenderOptions = {}): boolean {
+    return options.decorate ?? true
+}
+
+function applyAnsi(text: string, code: number, options: RenderOptions = {}): string {
+    if (!isDecorated(options)) {
+        return text
+    }
+
+    return `\u001B[${code}m${text}\u001B[0m`
+}
+
+function bold(text: string, options: RenderOptions = {}): string {
+    return applyAnsi(text, 1, options)
+}
+
+function color(text: string, code: number, options: RenderOptions = {}): string {
+    return applyAnsi(text, code, options)
+}
+
+function linesOf(input: string | string[]): string[] {
+    return Array.isArray(input)
+        ? input.flatMap(part => String(part).split('\n'))
+        : String(input).split('\n')
+}
+
+function stripAnsi(input: string): string {
+    return input.replace(/\u001B\[[0-9;]*m/g, '')
+}
+
+function visibleWidth(input: string): number {
+    return stripAnsi(input).length
+}
+
+function padRight(input: string, width: number): string {
+    const padding = Math.max(0, width - visibleWidth(input))
+    return `${input}${' '.repeat(padding)}`
+}
+
+export function heading(text: string, options: RenderOptions = {}): string {
+    return bold(text, options)
+}
+
+export function pane(
+    title: string,
+    content: string | string[],
+    options: RenderOptions = {},
+): string {
+    const decorate = isDecorated(options)
+    const inner = linesOf(content)
+    const header = decorate
+        ? color(`┌─ ${title}`, 36, options)
+        : `[${title}]`
+    const body = inner.map(line => decorate ? `│ ${line}` : line)
+
+    return [header, ...body].join('\n')
+}
+
+function renderPixelArtLine(row: string, options: RenderOptions = {}): string {
+    if (!isDecorated(options)) {
+        return renderBootstrapAsciiLine(row)
+    }
+
+    return row
+        .split('')
+        .map((cell) => {
+            const level = Number.parseInt(cell, 16)
+            const colorIndex = 232 + Math.round((level / 15) * 23)
+            return `\u001B[48;5;${colorIndex}m  \u001B[0m`
+        })
+        .join('')
+}
+
+export function renderBootstrapAsciiLine(row: string): string {
+    return row
+        .split('')
+        .map((cell) => {
+            const level = Number.parseInt(cell, 16)
+            const index = Math.round((level / 15) * (ASCII_PIXEL_RAMP.length - 1))
+            return ASCII_PIXEL_RAMP[index] ?? ' '
+        })
+        .join('')
+}
+
+export function getBootstrapAsciiArt(): string[] {
+    return BOOTSTRAP_PIXEL_ROWS.map(renderBootstrapAsciiLine)
+}
+
+export function getBootstrapPixelRows(): readonly string[] {
+    return BOOTSTRAP_PIXEL_ROWS
+}
+
+export function getTelaAsciiHeader(): string[] {
+    return [...TELA_ASCII_HEADER]
+}
+
+function renderAsciiHeaderLine(line: string, options: RenderOptions = {}): string {
+    return isDecorated(options) ? color(line, 97, options) : line
+}
+
+export function bootstrapPane(
+    title: string,
+    content: string | string[],
+    options: RenderOptions = {},
+): string {
+    return pane(
+        title,
+        [
+            '',
+            ...TELA_ASCII_HEADER.map(line => renderAsciiHeaderLine(line, options)),
+            '',
+            ...BOOTSTRAP_PIXEL_ROWS.map(row => renderPixelArtLine(row, options)),
+            '',
+            ...linesOf(content),
+        ],
+        options,
+    )
+}
+
+export function section(
+    title: string,
+    content: string | string[],
+    options: RenderOptions = {},
+): string {
+    const lines = linesOf(content)
+    return [
+        heading(title, options),
+        ...lines.map(line => line ? `  ${line}` : ''),
+    ].join('\n')
+}
+
+export function kvList(
+    entries: Array<{ label: string, value: string }>,
+    options: RenderOptions = {},
+): string {
+    if (entries.length === 0) {
+        return ''
+    }
+
+    const labelWidth = entries.reduce((max, entry) => Math.max(max, entry.label.length), 0)
+    return entries
+        .map(entry => `${padRight(`${entry.label}:`, labelWidth + 1)} ${entry.value}`)
+        .join('\n')
+}
+
+export function stepList(steps: string[]): string {
+    return steps
+        .map((step, index) => `${index + 1}. ${step}`)
+        .join('\n')
+}
+
+export function bulletList(items: string[], prefix = '- '): string {
+    return items.map(item => `${prefix}${item}`).join('\n')
+}
+
+export function callout(
+    kind: 'info' | 'warn' | 'error' | 'success',
+    title: string,
+    content: string | string[],
+    options: RenderOptions = {},
+): string {
+    const prefixMap = {
+        info: { symbol: 'i', color: 36 },
+        warn: { symbol: '!', color: 33 },
+        error: { symbol: 'x', color: 31 },
+        success: { symbol: '✓', color: 32 },
+    } as const
+
+    const prefix = prefixMap[kind]
+    const decorate = isDecorated(options)
+    const marker = decorate
+        ? color(prefix.symbol, prefix.color, options)
+        : prefix.symbol
+
+    return pane(
+        `${marker} ${title}`,
+        content,
+        options,
+    )
+}
+
+export function resultCard(
+    title: string,
+    sections: Array<string | undefined | null>,
+    options: RenderOptions = {},
+): string {
+    return pane(
+        title,
+        sections.filter(Boolean).join('\n\n'),
+        options,
+    )
+}
+
+export function errorCard(input: {
+    summary: string
+    details?: string
+    fixes?: string[]
+    evidence?: string[]
+}, options: RenderOptions = {}): string {
+    const parts: string[] = []
+
+    if (input.details) {
+        parts.push(input.details)
+    }
+
+    if (input.fixes?.length) {
+        parts.push(section('How to fix it', stepList(input.fixes), options))
+    }
+
+    if (input.evidence?.length) {
+        parts.push(section('Evidence', bulletList(input.evidence), options))
+    }
+
+    return callout('error', input.summary, parts, options)
+}
+
+export function nextActions(actions: string[], options: RenderOptions = {}): string {
+    return section('Next actions', stepList(actions), options)
+}
+
+export function table(
+    headers: string[],
+    rows: string[][],
+    options: RenderOptions = {},
+): string {
+    const allRows = [headers, ...rows]
+    const widths = headers.map((_, columnIndex) => allRows.reduce((max, row) => {
+        return Math.max(max, visibleWidth(row[columnIndex] ?? ''))
+    }, 0))
+
+    const divider = widths.map(width => '-'.repeat(width)).join('  ')
+    const renderedRows = allRows.map((row, rowIndex) => {
+        const rendered = row
+            .map((cell, columnIndex) => padRight(cell ?? '', widths[columnIndex] ?? 0))
+            .join('  ')
+
+        if (rowIndex === 0 && isDecorated(options)) {
+            return bold(rendered, options)
+        }
+
+        return rendered
+    })
+
+    return [renderedRows[0] ?? '', divider, ...renderedRows.slice(1)].join('\n')
+}
+
+export function joinBlocks(blocks: Array<string | undefined | null>): string {
+    return blocks
+        .filter((block): block is string => Boolean(block && block.trim()))
+        .join('\n\n')
+}