@meistrari/tela-cli 0.7.0 → 0.7.4

package/src/runtime.ts

@@ -1,147 +0,0 @@
-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

@@ -1,165 +0,0 @@
-export type TelaEnvironment = 'production' | 'staging' | 'custom'
-
-export interface TelaCliUser {
-    id: string
-    email: string
-    name: string
-}
-
-export interface TelaCliWorkspace {
-    id: string
-    title: string
-}
-
-export interface TelaCliSession {
-    accessToken: string
-    refreshToken: string
-    expiresAt: number
-}
-
-export interface TelaCliForgejoOrganization {
-    id: string
-    name: string
-}
-
-export interface TelaCliGitSshKey {
-    title: string
-    publicKeyPath: string
-    privateKeyPath: string
-}
-
-export interface TelaCliAuthState {
-    user: TelaCliUser
-    workspace: TelaCliWorkspace
-    session: TelaCliSession
-}
-
-export interface TelaCliConfig {
-    environment: TelaEnvironment
-    agentApiUrl: string
-    authApiUrl: string
-    authDashboardUrl: string
-    telaApiUrl: string
-    cloneRoot: string
-    requesterApplicationId: string
-    targetApplicationId: string
-    auth: TelaCliAuthState | null
-    forgejoOrganization: TelaCliForgejoOrganization | null
-    forgejoUserRegistered: boolean
-    gitSshKey: TelaCliGitSshKey | null
-}
-
-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 interface RepositoryListItemResponse {
-    organization: OrganizationSummary
-    agentRepo: AgentRepoSummary
-}
-
-export interface RepositoryListResponse {
-    success: boolean
-    repositories?: RepositoryListItemResponse[]
-    error?: string
-}
-
-export interface AvailableRepositorySummary extends RepositoryListItemResponse {
-    syncStatus: 'available'
-}
-
-export interface OrganizationListResponse {
-    success: boolean
-    organizations?: TelaCliForgejoOrganization[]
-    error?: string
-}
-
-export interface ForgejoUserSshKeyInput {
-    title: string
-    key: string
-    readOnly?: boolean
-}
-
-export interface ForgejoUserCreateResponse {
-    success: boolean
-    username?: string
-    email?: string
-    organizationName?: string
-    teamName?: string
-    teamId?: number
-    userCreated?: boolean
-    teamCreated?: boolean
-    sshKeyCreated?: boolean
-    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

@@ -1,295 +0,0 @@
-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)),
-            '',
-            ...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')
-}

package/src/version.ts

@@ -1,3 +0,0 @@
-import packageJson from '../package.json' with { type: 'json' }
-
-export const CLI_VERSION = packageJson.version