bimba-cli 0.7.30 → 0.7.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bimba-cli",
-  "version": "0.7.30",
+  "version": "0.7.32",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HeapVoid/bimba.git"

package/serve.js

@@ -3,7 +3,6 @@ import * as compiler from 'imba/compiler'
 import { mkdirSync, watch, existsSync, statSync, writeFileSync, realpathSync } from 'fs'
 import path from 'path'
 import { theme } from './utils.js'
-import { printerr } from './plugin.js'
 
 // ─── HMR Client (injected into browser) ──────────────────────────────────────
 
@@ -628,29 +627,69 @@ export function serve(entrypoint, flags) {
 	const srcDir   = path.dirname(entrypoint)
 	const sockets  = new Set()
 
-	// ── Status line (prints current compile result, fades out on success) ──────
+	// ── Live status block (shows only the current compile state) ───────────────
 
-	let _fadeTimers = []
-	let _fadeId = 0
+	let _statusRows = 0
+	let _statusTimer = null
 	let _statusFile = null
-	let _statusSaved = false
-	let _statusKind = null
+	let _statusInline = false
+	let _statusWidth = 0
+	let _eraseTimers = []
 	const _isTTY = process.stdout.isTTY
 
-	function cancelFade() {
-		_fadeTimers.forEach(t => clearTimeout(t))
-		_fadeTimers = []
+	function stripAnsi(text) {
+		return String(text).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '')
+	}
+
+	function renderedRows(lines) {
+		const columns = Math.max(1, process.stdout.columns || 80)
+		return lines.reduce((total, line) => {
+			const length = stripAnsi(line).length
+			return total + Math.max(1, Math.ceil(length / columns))
+		}, 0)
 	}
 
 	function clearStatus(file) {
-		if (file && _statusFile && _statusFile !== file) return
-		cancelFade()
-		if (_statusSaved) {
-			process.stdout.write('\x1b[u\x1b[J')
-			_statusSaved = false
+		if (file && _statusFile && _statusFile !== file) return false
+		if (_statusTimer) {
+			clearTimeout(_statusTimer)
+			_statusTimer = null
+		}
+		_eraseTimers.forEach(timer => clearTimeout(timer))
+		_eraseTimers = []
+		if (_isTTY && _statusInline) {
+			process.stdout.write('\r\x1b[J')
+		} else if (_isTTY && _statusRows) {
+			process.stdout.write(`\x1b[${_statusRows}A\r\x1b[J`)
 		}
+		_statusRows = 0
 		_statusFile = null
-		_statusKind = null
+		_statusInline = false
+		_statusWidth = 0
+		return true
+	}
+
+	function formatErrorLines(errors) {
+		const lines = []
+		for (const err of errors || []) {
+			const message = errorMessage(err)
+			const line = errorLine(err)
+			lines.push(`           ${theme.error(' ' + message + ' ')}${line != null ? theme.margin(` line ${line + 1} `) : ''}`)
+			const snippet = errorSnippet(err)
+			if (snippet && snippet !== message) {
+				lines.push(...String(snippet).split('\n').slice(0, 6).map(item => `           ${theme.code(item)}`))
+			}
+			lines.push('')
+		}
+		return lines
+	}
+
+	function statusLines(file, state, errors) {
+		const now = new Date().toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit', second: '2-digit' })
+		const status = state === 'ok' ? theme.success(' ok ') : theme.failure(' fail ')
+		const lines = [`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}`]
+		if (errors?.length) lines.push('', ...formatErrorLines(errors))
+		return lines
 	}
 
 	function printStatus(file, state, errors, options = {}) {
@@ -670,45 +709,46 @@ export function serve(entrypoint, flags) {
 			return
 		}
 
-		cancelFade()
-		if (_statusSaved) {
-			process.stdout.write('\x1b[u\x1b[J')
-			_statusSaved = false
+		clearStatus()
+		_statusFile = file
+		const lines = statusLines(file, state, errors)
+		if (options.fadeAfter && lines.length === 1) {
+			const plain = stripAnsi(lines[0])
+			process.stdout.write(lines[0])
+			_statusRows = 1
+			_statusInline = true
+			_statusWidth = plain.length
+			_statusTimer = setTimeout(() => eraseStatus(file), options.fadeAfter)
+			return
 		}
-		const now = new Date().toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit', second: '2-digit' })
-		const status = state === 'ok' ? theme.success(' ok ') : theme.failure(' fail ')
 
-		if (errors?.length || options.sticky) {
-			process.stdout.write(`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}\n`)
-			if (errors?.length) {
-				for (const err of errors) {
-					try { printerr(err) } catch(_) { process.stdout.write('  ' + err.message + '\n') }
-				}
-			}
-			_statusFile = null
-			_statusKind = null
+		process.stdout.write(lines.join('\n') + '\n')
+		_statusRows = renderedRows(lines)
+
+		if (options.clearAfter) _statusTimer = setTimeout(() => clearStatus(file), options.clearAfter)
+	}
+
+	function eraseStatus(file) {
+		if (file && _statusFile && _statusFile !== file) return
+		_statusTimer = null
+		if (!_isTTY || !_statusInline) {
+			clearStatus(file)
 			return
 		}
 
-		process.stdout.write('\x1b[s')
-		_statusSaved = true
-		_statusFile = file
-		_statusKind = state
-
-		const myId = ++_fadeId
-		const plainLine = `  ${now}  ${file}   ok `
-		const total = plainLine.length
-		process.stdout.write(`  ${theme.folder(now)}  ${theme.filename(file)}  ${status}`)
+		const total = _statusWidth
 		for (let i = 1; i <= total; i++) {
-			_fadeTimers.push(setTimeout(() => {
-				if (_fadeId !== myId) return
+			_eraseTimers.push(setTimeout(() => {
+				if (!_statusInline || _statusFile !== file) return
 				process.stdout.write('\x1b[1D \x1b[1D')
 				if (i === total) {
-					_statusSaved = false
+					_statusRows = 0
 					_statusFile = null
-					_statusKind = null
+					_statusInline = false
+					_statusWidth = 0
+					_eraseTimers = []
 				}
-			}, 5000 + i * 22))
+			}, i * 22))
 		}
 	}
 
@@ -853,9 +893,72 @@ export function serve(entrypoint, flags) {
 			.join('\n---\n')
 	}
 
+	function renderActiveErrors() {
+		if (!_isTTY) return false
+		if (!_activeErrors.size) {
+			clearStatus()
+			return false
+		}
+
+		clearStatus()
+		const lines = []
+		for (const item of _activeErrors.values()) {
+			if (lines.length) lines.push('')
+			lines.push(...statusLines(item.file, 'fail', item.errors))
+		}
+		process.stdout.write(lines.join('\n') + '\n')
+		_statusFile = null
+		_statusRows = renderedRows(lines)
+		return true
+	}
+
+	function existingFileForError(file) {
+		for (const candidate of fileCandidates(file)) {
+			try {
+				const stat = statSync(candidate)
+				if (stat.isFile()) return candidate
+			} catch(_) {
+				// ignore aliases that no longer exist
+			}
+		}
+		return null
+	}
+
+	async function reconcileActiveErrors() {
+		if (!_activeErrors.size) return false
+
+		let changed = false
+		const items = Array.from(_activeErrors.values())
+		for (const item of items) {
+			const filepath = existingFileForError(item.file)
+			if (!filepath) {
+				if (takeError(item.file)) {
+					_terminalErrors.delete(terminalErrorKey(item.file))
+					broadcast({ type: 'clear-error', file: item.file })
+					changed = true
+				}
+				continue
+			}
+
+			if (!filepath.endsWith('.imba')) continue
+
+			const out = await compileFile(filepath)
+			if (out.errors?.length) continue
+
+			if (takeError(item.file)) {
+				_terminalErrors.delete(terminalErrorKey(item.file))
+				broadcast({ type: 'clear-error', file: item.file })
+				changed = true
+			}
+		}
+
+		return changed
+	}
+
 	function showTrackedError(item) {
 		const file = item.file
-		printStatus(file, 'fail', item.errors)
+		if (_isTTY) renderActiveErrors()
+		else printStatus(file, 'fail', item.errors)
 		broadcast({ type: 'error', file, time: item.time, errors: item.payload })
 	}
 
@@ -884,9 +987,10 @@ export function serve(entrypoint, flags) {
 		_activeErrors.set(key, item)
 		_terminalErrors.set(terminalKey, { signature: printSignature, time: now })
 
-		// The terminal is append-only in many real shells. Repeated reports of the
-		// same active error update the browser overlay, but must not print again.
+		// Repeated reports of the same active error update the live status and
+		// browser overlay, but do not create another terminal entry.
 		if (duplicate) {
+			if (_isTTY) renderActiveErrors()
 			broadcast({ type: 'error', file: display, time: item.time, errors: item.payload })
 			return
 		}
@@ -909,25 +1013,36 @@ export function serve(entrypoint, flags) {
 		const wasStatusFile = key && _statusFile && sameFile(_statusFile, key)
 		const hadError = key ? !!takeError(key) : _activeErrors.size > 0
 
-		if (!key) _activeErrors.clear()
+		if (!key) {
+			_activeErrors.clear()
+			_terminalErrors.clear()
+		} else if (hadError) {
+			_terminalErrors.delete(terminalErrorKey(key))
+		}
 
-		if (!key || hadError || wasStatusFile) clearStatus(key)
+		let showedNext = false
+		if (_isTTY && _activeErrors.size) showedNext = renderActiveErrors()
+		else if (!key || hadError || wasStatusFile) clearStatus(key)
 
 		broadcast({ type: 'clear-error', file: key })
 
-		return { cleared: hadError || wasStatusFile, file: key, showedNext: false }
+		return { cleared: hadError || wasStatusFile, file: key, showedNext }
 	}
 
-	function markSuccess(file) {
+	async function markSuccess(file) {
 		const key = normalizeFile(file)
 		const result = clearError(key)
+		const reconciled = await reconcileActiveErrors()
 		const active = _activeErrors.size
-		const shouldPrint = result?.cleared && !result.showedNext
+		let showedNext = false
+		if (active && _isTTY) showedNext = renderActiveErrors()
+		else if (_isTTY && (reconciled || result.showedNext)) clearStatus()
+		else showedNext = result.showedNext
+		const shouldPrint = (result?.cleared || reconciled) && !showedNext && !active
 		if (shouldPrint) {
-			_terminalErrors.delete(terminalErrorKey(key))
-			printStatus(key, 'ok', null, { sticky: true })
+			printStatus(key, 'ok', null, { fadeAfter: 3500 })
 		}
-		return { cleared: !!result?.cleared, printed: !!shouldPrint, showedNext: !!result?.showedNext, active }
+		return { cleared: !!result?.cleared || reconciled, printed: !!shouldPrint, showedNext: !!showedNext, active }
 	}
 
 	const _debounce = new Map()
@@ -995,12 +1110,12 @@ export function serve(entrypoint, flags) {
 				return
 			}
 
-			const success = markSuccess(rel)
+			const success = await markSuccess(rel)
 
 			// No change at all — skip
 			if (out.changeType === 'none' || out.changeType === 'cached') return
 
-			if (!success.printed && !success.showedNext && !success.active) printStatus(rel, 'ok')
+			if (!success.printed && !success.showedNext && !success.active) printStatus(rel, 'ok', null, { fadeAfter: 3500 })
 			broadcast({ type: 'update', file: rel, slots: out.slots || 'shifted' })
 		} catch(e) {
 			if (!isCurrentChange(file, version)) return
@@ -1038,7 +1153,7 @@ export function serve(entrypoint, flags) {
 				const file = 'vendor:' + (specifier || pathname)
 				const bundled = specifier ? await bundleVendor(specifier) : null
 				if (bundled?.code) {
-					markSuccess(file)
+					await markSuccess(file)
 					return new Response(bundled.code, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 
@@ -1051,7 +1166,7 @@ export function serve(entrypoint, flags) {
 				const file = 'html:' + normalizeFile(htmlFile)
 				try {
 					let html = await Bun.file(htmlFile).text()
-					markSuccess(file)
+					await markSuccess(file)
 					return new Response(transformHtml(html, entrypoint), {
 						headers: { 'Content-Type': 'text/html' },
 					})
@@ -1077,7 +1192,7 @@ export function serve(entrypoint, flags) {
 					if (out.errors?.length) {
 						return errorResponse(file, out.errors)
 					}
-					markSuccess(file)
+					await markSuccess(file)
 					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				} catch(e) {
 					if (isMissingFileError(e)) {
@@ -1099,7 +1214,7 @@ export function serve(entrypoint, flags) {
 				try {
 					if (cssFile && await cssFile.exists()) {
 						if (req.headers.get('sec-fetch-dest') === 'style') {
-							markSuccess(file)
+							await markSuccess(file)
 							return new Response(cssFile, { headers: { 'Content-Type': 'text/css' } })
 						}
 
@@ -1111,7 +1226,7 @@ export function serve(entrypoint, flags) {
 							`if (!el) { el = document.createElement('style'); el.setAttribute('data-bimba-css', id); document.head.appendChild(el); }`,
 							`el.textContent = ${JSON.stringify(css)};`,
 						].join('\n')
-						markSuccess(file)
+						await markSuccess(file)
 						return new Response(js, { headers: { 'Content-Type': 'application/javascript' } })
 					}
 				} catch (error) {
@@ -1129,7 +1244,7 @@ export function serve(entrypoint, flags) {
 					const file = 'js:' + normalizeFile(jsFile)
 					try {
 						const response = await serveJavaScriptFile(jsFile)
-						markSuccess(file)
+						await markSuccess(file)
 						return response
 					} catch (error) {
 						if (isMissingFileError(error)) {
@@ -1156,7 +1271,7 @@ export function serve(entrypoint, flags) {
 					if (out.errors?.length) {
 						return errorResponse(file, out.errors)
 					}
-					markSuccess(file)
+					await markSuccess(file)
 					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 
@@ -1164,7 +1279,7 @@ export function serve(entrypoint, flags) {
 					const file = 'vendor:' + normalizeFile(pathname)
 					const bundled = await bundleVendor(path.resolve(resolved))
 					if (bundled?.code) {
-						markSuccess(file)
+						await markSuccess(file)
 						return new Response(bundled.code, { headers: { 'Content-Type': 'application/javascript' } })
 					}
 					return errorResponse(file, bundled?.errors || [`Could not bundle ${pathname}`])
@@ -1176,13 +1291,13 @@ export function serve(entrypoint, flags) {
 				const inHtmlDirPath = path.join(htmlDir, pathname)
 				const inHtmlDir = Bun.file(inHtmlDirPath)
 				if (await inHtmlDir.exists()) {
-					markSuccess('static:' + normalizeFile(inHtmlDirPath))
+					await markSuccess('static:' + normalizeFile(inHtmlDirPath))
 					return new Response(inHtmlDir)
 				}
 				const inRootPath = '.' + pathname
 				const inRoot = Bun.file(inRootPath)
 				if (await inRoot.exists()) {
-					markSuccess('static:' + normalizeFile(inRootPath))
+					await markSuccess('static:' + normalizeFile(inRootPath))
 					return new Response(inRoot)
 				}
 			} catch (error) {
@@ -1204,7 +1319,7 @@ export function serve(entrypoint, flags) {
 					if (out.errors?.length) {
 						return errorResponse(file, out.errors)
 					}
-					markSuccess(file)
+					await markSuccess(file)
 					return new Response(out.js, { headers: { 'Content-Type': 'application/javascript' } })
 				}
 				for (const ext of ['.js', '.mjs']) {
@@ -1213,7 +1328,7 @@ export function serve(entrypoint, flags) {
 						const file = 'js:' + normalizeFile(withExt)
 						try {
 							const response = await serveJavaScriptFile(withExt)
-							markSuccess(file)
+							await markSuccess(file)
 							return response
 						} catch (error) {
 							if (isMissingFileError(error)) {
@@ -1231,7 +1346,7 @@ export function serve(entrypoint, flags) {
 				const file = 'html:' + normalizeFile(htmlPath)
 				try {
 					let html = await Bun.file(htmlPath).text()
-					markSuccess(file)
+					await markSuccess(file)
 					return new Response(transformHtml(html, entrypoint), {
 						headers: { 'Content-Type': 'text/html' },
 					})