@meistrari/tela-cli 0.7.0 → 0.7.5

package/src/commands/status.ts

@@ -1,109 +0,0 @@
-import {
-    createStatusReport,
-    getAgentApiOriginCheckStatus,
-    type StatusReport,
-} from '../diagnostics.ts'
-import { joinBlocks, kvList, nextActions, resultCard, section, table, type RenderOptions } from '../ui.ts'
-
-function renderWarnings(report: StatusReport, options: RenderOptions): string | undefined {
-    if (report.warnings.length === 0) {
-        return undefined
-    }
-
-    return section(
-        'Warnings',
-        report.warnings.map(warning => `- ${warning}`).join('\n'),
-        options,
-    )
-}
-
-export function renderStatusReport(report: StatusReport, options: RenderOptions = {}): string {
-    const configSection = section('Config', kvList([
-        { label: 'Path', value: report.config.path },
-        { label: 'Present', value: report.config.present ? 'yes' : 'no' },
-        { label: 'Valid', value: report.config.valid ? 'yes' : 'no' },
-        { label: 'Environment', value: report.config.environment ?? '<unconfigured>' },
-        { label: 'Agent API origin', value: report.config.agentApiUrl ?? '<unconfigured>' },
-        { label: 'Auth API URL', value: report.config.authApiUrl ?? '<unconfigured>' },
-        { label: 'Tela API URL', value: report.config.telaApiUrl ?? '<unconfigured>' },
-        { label: 'Clone root', value: report.config.cloneRoot ?? '<unconfigured>' },
-        { label: 'User', value: report.config.user ?? '<signed out>' },
-        { label: 'Workspace', value: report.config.workspace ?? '<signed out>' },
-        { label: 'Organization', value: report.config.forgejoOrganization ?? '<not selected>' },
-        { label: 'Forgejo user', value: report.config.forgejoUserRegistered == null ? '<unknown>' : (report.config.forgejoUserRegistered ? 'registered' : 'pending') },
-        { label: 'Git SSH key', value: report.config.gitSshKeyTitle ?? '<missing>' },
-        { label: 'Git SSH public key', value: report.config.gitSshPublicKeyPath ?? '<missing>' },
-        { label: 'Git SSH private key', value: report.config.gitSshPrivateKeyPath ?? '<missing>' },
-        { label: 'Access token', value: report.config.accessToken ?? '<missing>' },
-        { label: 'Session expiry', value: report.config.sessionExpiresAt ? new Date(report.config.sessionExpiresAt).toISOString() : '<missing>' },
-        { label: 'Refresh token', value: report.config.hasRefreshToken ? 'present' : 'missing' },
-    ], options), options)
-
-    const repoSection = section('Repository', kvList([
-        { label: 'CWD', value: report.repo.cwd },
-        { label: 'Inside repo', value: report.repo.inRepository ? 'yes' : 'no' },
-        { label: 'Repo root', value: report.repo.repoRoot ?? '<none>' },
-        { label: 'HEAD', value: report.repo.head ?? '<unknown>' },
-        { label: 'Branch', value: report.repo.detached ? '<detached>' : (report.repo.branch ?? '<unknown>') },
-        { label: 'Upstream', value: report.repo.upstream ?? '<none>' },
-        { label: 'Dirty', value: report.repo.dirty ? 'yes' : 'no' },
-        { label: 'Origin', value: report.repo.originUrl ?? '<missing>' },
-    ], options), options)
-
-    const toolRows = [
-        ['git', report.tools.git ? 'available' : 'missing', report.tools.git ? 'ready' : 'install git'],
-        [
-            'claude',
-            !report.tools.claude
-                ? 'missing'
-                : (report.tools.claudeProjectScopedRunSupported === false ? 'unsupported' : 'available'),
-            !report.tools.claude
-                ? 'required for `tela run`, `tela feedback`, and Claude commit messages'
-                : (report.tools.claudeProjectScopedRunSupported === false
-                    ? (report.tools.claudeDetail ?? `version ${report.tools.claudeVersion ?? '<unknown>'}`)
-                    : (report.tools.claudeVersion ? `version ${report.tools.claudeVersion}` : 'ready')),
-        ],
-        [
-            'agent-api-origin',
-            report.tools.agentApiReachable === null
-                ? 'skipped'
-                : getAgentApiOriginCheckStatus({
-                    reachable: report.tools.agentApiReachable,
-                    category: report.tools.agentApiCategory ?? 'network_error',
-                    statusCode: report.tools.agentApiStatus,
-                    detail: report.tools.agentApiDetail ?? '<not checked>',
-                }),
-            report.tools.agentApiDetail ?? '<not checked>',
-        ],
-    ]
-    const toolsSection = section('Tools', table(['Tool', 'Status', 'Detail'], toolRows, options), options)
-
-    const changesSection = report.repo.shortStatus
-        ? section('Worktree', report.repo.shortStatus, options)
-        : undefined
-
-    return resultCard('Tela status', [
-        configSection,
-        toolsSection,
-        repoSection,
-        changesSection,
-        renderWarnings(report, options),
-        nextActions(report.nextActions, options),
-    ], options)
-}
-
-export async function getStatusReport(cwd = process.cwd(), fetchFn: typeof fetch = fetch): Promise<StatusReport> {
-    return await createStatusReport(cwd, fetchFn)
-}
-
-export async function runStatusCommand(input: {
-    cwd?: string
-    json?: boolean
-    fetchFn?: typeof fetch
-} = {}): Promise<{ report: StatusReport, output?: string }> {
-    const report = await getStatusReport(input.cwd, input.fetchFn)
-    return {
-        report,
-        output: input.json ? undefined : renderStatusReport(report, { decorate: Boolean(process.stdout.isTTY) }),
-    }
-}

package/src/commands/sync.ts

@@ -1,245 +0,0 @@
-import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-import { fetchRepositoryLookup } from '../agent-api.ts'
-import type { FetchLike } from '../auth.ts'
-import {
-    assertGitRepository,
-    cloneRepository,
-    fetchAllRemotes,
-    fetchOrigin,
-    getCurrentBranch,
-    getHeadShortSha,
-    getOriginUrl,
-    findRepositoryRoot,
-    getRepositoryRoot,
-    getUpstreamBranch,
-    isWorktreeDirty,
-    pullCurrentBranch,
-    pullDefaultBranch,
-} from '../git.ts'
-import type { BatchSyncResult, SyncResult, TelaCliConfig } from '../types.ts'
-
-export type SyncFailureCategory =
-    | 'dirty_worktree'
-    | 'detached_head'
-    | 'origin_mismatch'
-    | 'missing_upstream'
-    | 'missing_default_branch'
-    | 'not_git_repository'
-    | 'other'
-
-export interface SyncAllProgressEvent {
-    targetDir: string
-    status: 'running' | 'success' | 'failure'
-    result?: SyncResult
-    error?: string
-}
-
-function normalizeRemoteUrl(url: string): string {
-    return url.trim().replace(/\/+$/, '')
-}
-
-function normalizePath(path: string): string {
-    return realpathSync(path)
-}
-
-export async function syncCurrentRepository(cwd = process.cwd()): Promise<SyncResult> {
-    const targetDir = await getRepositoryRoot(cwd)
-
-    await fetchAllRemotes(targetDir)
-
-    if (await isWorktreeDirty(targetDir)) {
-        throw new Error(`Worktree is dirty: ${targetDir}`)
-    }
-
-    const branch = await getCurrentBranch(targetDir)
-    const upstream = await getUpstreamBranch(targetDir)
-    if (!upstream) {
-        throw new Error(`Current branch does not track a remote branch: ${branch}`)
-    }
-
-    await pullCurrentBranch(targetDir)
-
-    return {
-        targetDir,
-        branch,
-        head: await getHeadShortSha(targetDir),
-        cloned: false,
-    }
-}
-
-export async function syncAllRepositories(
-    cloneRoot: string,
-    options: {
-        onProgress?: (event: SyncAllProgressEvent) => void
-    } = {},
-): Promise<BatchSyncResult> {
-    if (!existsSync(cloneRoot)) {
-        throw new Error(`Clone root does not exist: ${cloneRoot}`)
-    }
-
-    const cloneRootStat = statSync(cloneRoot)
-    if (!cloneRootStat.isDirectory()) {
-        throw new Error(`Clone root is not a directory: ${cloneRoot}`)
-    }
-
-    const repoDirs: string[] = []
-    for (const entry of readdirSync(cloneRoot, { withFileTypes: true })) {
-        if (!entry.isDirectory()) {
-            continue
-        }
-
-        const entryPath = join(cloneRoot, entry.name)
-        const repoRoot = await findRepositoryRoot(entryPath)
-        if (!repoRoot) {
-            continue
-        }
-
-        if (normalizePath(repoRoot) !== normalizePath(entryPath)) {
-            continue
-        }
-
-        repoDirs.push(entryPath)
-    }
-
-    repoDirs.sort((left, right) => left.localeCompare(right))
-
-    const successes: SyncResult[] = []
-    const failures: BatchSyncResult['failures'] = []
-
-    for (const repoDir of repoDirs) {
-        options.onProgress?.({
-            targetDir: repoDir,
-            status: 'running',
-        })
-
-        try {
-            const result = await syncCurrentRepository(repoDir)
-            successes.push(result)
-            options.onProgress?.({
-                targetDir: repoDir,
-                status: 'success',
-                result,
-            })
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error)
-            failures.push({
-                targetDir: repoDir,
-                error: errorMessage,
-                category: categorizeSyncError(error),
-            })
-            options.onProgress?.({
-                targetDir: repoDir,
-                status: 'failure',
-                error: errorMessage,
-            })
-        }
-    }
-
-    return { successes, failures }
-}
-
-export function categorizeSyncError(error: unknown): SyncFailureCategory {
-    const message = error instanceof Error ? error.message : String(error)
-
-    if (message.includes('Worktree is dirty')) {
-        return 'dirty_worktree'
-    }
-
-    if (message.includes('Detached HEAD')) {
-        return 'detached_head'
-    }
-
-    if (message.includes('Origin mismatch')) {
-        return 'origin_mismatch'
-    }
-
-    if (message.includes('does not track a remote branch')) {
-        return 'missing_upstream'
-    }
-
-    if (message.includes('does not expose a default branch')) {
-        return 'missing_default_branch'
-    }
-
-    if (message.includes('Not a git repository')) {
-        return 'not_git_repository'
-    }
-
-    return 'other'
-}
-
-export function listCloneRootRepositories(cloneRoot: string): string[] {
-    if (!existsSync(cloneRoot)) {
-        return []
-    }
-
-    const cloneRootStat = statSync(cloneRoot)
-    if (!cloneRootStat.isDirectory()) {
-        return []
-    }
-
-    return readdirSync(cloneRoot, { withFileTypes: true })
-        .filter(entry => entry.isDirectory())
-        .map(entry => entry.name)
-        .sort((left, right) => left.localeCompare(right))
-}
-
-export async function syncRepository(
-    repository: string,
-    config: TelaCliConfig,
-    fetchFn: FetchLike = fetch,
-): Promise<SyncResult> {
-    const repoDetails = await fetchRepositoryLookup(repository, config, fetchFn)
-    const targetDir = join(config.cloneRoot, repository)
-
-    if (!existsSync(targetDir)) {
-        await cloneRepository(repoDetails.forgejoRepository.sshUrl, targetDir)
-        return {
-            targetDir,
-            branch: await getCurrentBranch(targetDir),
-            head: await getHeadShortSha(targetDir),
-            cloned: true,
-        }
-    }
-
-    const targetStat = statSync(targetDir)
-    if (!targetStat.isDirectory()) {
-        throw new Error(`Target path exists but is not a directory: ${targetDir}`)
-    }
-
-    await assertGitRepository(targetDir)
-
-    const originUrl = await getOriginUrl(targetDir)
-    if (normalizeRemoteUrl(originUrl) !== normalizeRemoteUrl(repoDetails.forgejoRepository.sshUrl)) {
-        throw new Error(`Origin mismatch for ${targetDir}. Expected ${repoDetails.forgejoRepository.sshUrl}, found ${originUrl}`)
-    }
-
-    await fetchOrigin(targetDir)
-
-    if (await isWorktreeDirty(targetDir)) {
-        throw new Error(`Worktree is dirty: ${targetDir}`)
-    }
-
-    const branch = await getCurrentBranch(targetDir)
-    const upstream = await getUpstreamBranch(targetDir)
-
-    if (upstream) {
-        await pullCurrentBranch(targetDir)
-    }
-    else {
-        const defaultBranch = repoDetails.forgejoRepository.defaultBranch
-        if (!defaultBranch) {
-            throw new Error(`Repository ${repository} does not expose a default branch`)
-        }
-        await pullDefaultBranch(targetDir, defaultBranch)
-    }
-
-    return {
-        targetDir,
-        branch,
-        head: await getHeadShortSha(targetDir),
-        cloned: false,
-    }
-}

package/src/commit-message.ts

@@ -1,69 +0,0 @@
-import { basename } from 'node:path'
-import { commandExists, runCommand } from './process.ts'
-
-export interface ClaudeCommitContext {
-    status: string
-    diff: string
-    log: string
-}
-
-function firstNonEmptyLine(input: string): string {
-    return input
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .find(Boolean) ?? ''
-}
-
-export async function generateCommitMessageWithClaude(
-    context: ClaudeCommitContext,
-): Promise<string> {
-    if (!await commandExists('claude')) {
-        throw new Error('Claude CLI is not available')
-    }
-
-    const prompt = `You are writing a git commit message for already staged changes.
-
-Recent git status:
-${context.status || '<empty>'}
-
-Recent git diff --cached:
-${context.diff || '<empty>'}
-
-Recent git log:
-${context.log || '<empty>'}
-
-Write exactly one short natural-language git commit message.
-- Do not use conventional commit prefixes like feat:, fix:, or chore:
-- Focus on the purpose of the change
-- Keep it concise
-- Return only the commit message text`
-
-    const result = await runCommand([
-        'claude',
-        '-p',
-        prompt,
-        '--output-format',
-        'text',
-        '--tools',
-        '',
-    ])
-
-    const message = firstNonEmptyLine(result.stdout)
-    if (!message) {
-        throw new Error('Claude returned an empty commit message')
-    }
-
-    return message
-}
-
-export function fallbackCommitMessageFromFiles(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`
-}