@recombine-ai/bosun 0.13.0 → 0.15.0

package/src/lib/edit/prompt-highlighter.spec.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { createPromptHighlighter } from './prompt-highlighter'
+
+function positionAt(text: string, offset: number): { lineNumber: number; column: number } {
+	const clamped = Math.max(0, Math.min(text.length, offset))
+	const before = text.slice(0, clamped)
+	const lineNumber = before.split('\n').length
+	const lastNl = before.lastIndexOf('\n')
+	const column = clamped - (lastNl === -1 ? 0 : lastNl + 1) + 1
+	return { lineNumber, column }
+}
+
+class Range {
+	constructor(
+		public startLineNumber: number,
+		public startColumn: number,
+		public endLineNumber: number,
+		public endColumn: number
+	) {}
+}
+
+describe('prompt-highlighter', () => {
+	it('adds overview ruler marks and can focus next occurrence', () => {
+		const text = 'hello world\nhello again'
+		const model = {
+			getValue: () => text,
+			getPositionAt: (offset: number) => positionAt(text, offset)
+		}
+
+		const highlightCollection = { set: vi.fn(), clear: vi.fn() }
+		const focusCollection = { set: vi.fn(), clear: vi.fn() }
+		const collections = [highlightCollection, focusCollection]
+
+		const editor = {
+			getModel: () => model,
+			createDecorationsCollection: vi.fn(() => collections.shift()),
+			onDidChangeModelContent: vi.fn(() => ({ dispose: vi.fn() })),
+			setSelection: vi.fn(),
+			revealRangeInCenter: vi.fn(),
+			focus: vi.fn()
+		} as any
+
+		const monaco = {
+			Range,
+			editor: {
+				ScrollType: { Smooth: 0 },
+				OverviewRulerLane: { Center: 2 }
+			}
+		} as any
+
+		const highlighter = createPromptHighlighter(editor, monaco)
+
+		highlighter.setHighlights({
+			quotes: [{ quote: 'hello', count: 3 }],
+			focusQuote: null,
+			focusNonce: 0
+		})
+
+		expect(highlightCollection.set).toHaveBeenCalledTimes(1)
+		const decorations = highlightCollection.set.mock.calls[0][0]
+		expect(decorations).toHaveLength(2)
+		expect(decorations[0].options.inlineClassName).toContain('analysis-quote-l3')
+		expect(decorations[0].options.overviewRuler.position).toBe(
+			monaco.editor.OverviewRulerLane.Center
+		)
+		expect(decorations[0].options.overviewRuler.color).toContain('rgba(220, 38, 38')
+
+		highlighter.setHighlights({
+			quotes: [{ quote: 'hello', count: 3 }],
+			focusQuote: 'hello',
+			focusNonce: 1
+		})
+
+		expect(focusCollection.set).toHaveBeenCalledTimes(1)
+		expect(editor.revealRangeInCenter).toHaveBeenCalledTimes(1)
+		expect(editor.setSelection).toHaveBeenCalledTimes(1)
+		expect(editor.focus).toHaveBeenCalledTimes(1)
+	})
+})

package/src/lib/edit/prompt-highlighter.ts

@@ -0,0 +1,155 @@
+import type * as Monaco from 'monaco-editor'
+
+import type { PromptHighlights, QuoteCount } from './edit-vm'
+import type { OffsetRange } from './quote-matching'
+import { findAllOverlappingBestEffort } from './quote-matching'
+
+export interface PromptHighlighter {
+	setHighlights: (highlights: PromptHighlights | null) => void
+	dispose: () => void
+}
+
+export function createPromptHighlighter(
+	editor: Monaco.editor.IStandaloneCodeEditor,
+	monaco: typeof import('monaco-editor')
+): PromptHighlighter {
+	const highlightDecorations = editor.createDecorationsCollection()
+	const focusDecorations = editor.createDecorationsCollection()
+
+	let currentHighlights: PromptHighlights | null = null
+	let highlightRangesByQuote = new Map<string, OffsetRange[]>()
+	let cursorByQuote = new Map<string, number>()
+	let lastHandledFocusNonce = 0
+
+	function resetCaches() {
+		highlightRangesByQuote = new Map()
+		cursorByQuote = new Map()
+		lastHandledFocusNonce = 0
+	}
+
+	function clamp(n: number, min: number, max: number): number {
+		if (Number.isNaN(n)) return min
+		return Math.max(min, Math.min(max, n))
+	}
+
+	function overviewColorForLevel(level: number): string {
+		const l = clamp(level, 1, 10)
+		// Use a slightly higher opacity than the inline background so marks are visible in the overview ruler.
+		const alpha = clamp(0.22 + l * 0.06, 0.28, 0.82)
+		return `rgba(220, 38, 38, ${alpha})`
+	}
+
+	function getHighlightRanges(quote: string, text: string): OffsetRange[] {
+		const q = String(quote ?? '')
+		if (!q) return []
+		const cached = highlightRangesByQuote.get(q)
+		if (cached) return cached
+		const found = findAllOverlappingBestEffort(text, q)
+		highlightRangesByQuote.set(q, found)
+		return found
+	}
+
+	function updateHighlightDecorations(quotes: QuoteCount[]) {
+		const model = editor.getModel()
+		if (!model) return
+
+		const text = model.getValue() ?? ''
+		const decorations: Monaco.editor.IModelDeltaDecoration[] = []
+
+		// Weaker highlights first so stronger quotes can visually dominate overlaps.
+		const ordered = [...(quotes || [])].sort((a, b) => (a.count || 0) - (b.count || 0))
+		for (const q of ordered) {
+			const quote = String(q.quote || '')
+			if (!quote) continue
+			const level = clamp(Number(q.count || 0), 1, 10)
+			const color = overviewColorForLevel(level)
+			const matches = getHighlightRanges(quote, text)
+			for (const m of matches) {
+				const startPos = model.getPositionAt(m.start)
+				const endPos = model.getPositionAt(m.end)
+				decorations.push({
+					range: new monaco.Range(
+						startPos.lineNumber,
+						startPos.column,
+						endPos.lineNumber,
+						endPos.column
+					),
+					options: {
+						inlineClassName: `analysis-quote analysis-quote-l${level}`,
+						overviewRuler: { color, position: monaco.editor.OverviewRulerLane.Center }
+					}
+				})
+			}
+		}
+
+		highlightDecorations.set(decorations)
+	}
+
+	function revealNextOccurrence(quote: string) {
+		const model = editor.getModel()
+		if (!model) return
+
+		const text = model.getValue() ?? ''
+		const occurrences = getHighlightRanges(quote, text)
+		if (occurrences.length === 0) return
+
+		const current = cursorByQuote.get(quote) ?? -1
+		const nextIdx = (current + 1) % occurrences.length
+		cursorByQuote.set(quote, nextIdx)
+
+		const chosen = occurrences[nextIdx]
+		const startPos = model.getPositionAt(chosen.start)
+		const endPos = model.getPositionAt(chosen.end)
+		const range = new monaco.Range(
+			startPos.lineNumber,
+			startPos.column,
+			endPos.lineNumber,
+			endPos.column
+		)
+
+		focusDecorations.set([{ range, options: { inlineClassName: 'analysis-quote-focus' } }])
+		editor.setSelection(range)
+		editor.revealRangeInCenter(range, monaco.editor.ScrollType.Smooth)
+		editor.focus()
+	}
+
+	function applyHighlights(next: PromptHighlights | null) {
+		currentHighlights = next
+		if (!currentHighlights) {
+			highlightDecorations.clear()
+			focusDecorations.clear()
+			resetCaches()
+			return
+		}
+
+		updateHighlightDecorations(currentHighlights.quotes || [])
+
+		if (currentHighlights.focusQuote && currentHighlights.focusNonce !== lastHandledFocusNonce) {
+			lastHandledFocusNonce = currentHighlights.focusNonce
+			revealNextOccurrence(currentHighlights.focusQuote)
+		} else if (!currentHighlights.focusQuote) {
+			focusDecorations.clear()
+		}
+	}
+
+	const onDidChange = editor.onDidChangeModelContent(() => {
+		if (!currentHighlights) return
+		highlightRangesByQuote = new Map()
+		focusDecorations.clear()
+		updateHighlightDecorations(currentHighlights.quotes || [])
+	})
+
+	return {
+		setHighlights: applyHighlights,
+		dispose: () => {
+			try {
+				onDidChange.dispose()
+				highlightDecorations.clear()
+				focusDecorations.clear()
+			} finally {
+				currentHighlights = null
+				resetCaches()
+			}
+		}
+	}
+}

package/src/lib/edit/quote-matching.ts

@@ -0,0 +1,97 @@
+export type OffsetRange = { start: number; end: number }
+
+export function findAllOverlappingBestEffort(haystack: string, needle: string): OffsetRange[] {
+	const text = String(haystack ?? '')
+	const variants = buildNeedleVariants(needle)
+	const normalizedText = normalizeForMatching(text)
+
+	for (const variant of variants) {
+		const exact = findAllOverlappingExact(text, variant)
+		if (exact.length > 0) return exact
+
+		const flexible = findAllOverlappingFlexible(text, variant)
+		if (flexible.length > 0) return flexible
+
+		const normalizedNeedle = normalizeForMatching(variant)
+		if (normalizedText !== text || normalizedNeedle !== variant) {
+			const exactNorm = findAllOverlappingExact(normalizedText, normalizedNeedle)
+			if (exactNorm.length > 0) return exactNorm
+
+			const flexibleNorm = findAllOverlappingFlexible(normalizedText, normalizedNeedle)
+			if (flexibleNorm.length > 0) return flexibleNorm
+		}
+	}
+
+	return []
+}
+
+export function findAllOverlappingExact(haystack: string, needle: string): OffsetRange[] {
+	const n = String(needle ?? '')
+	if (!n) return []
+
+	const out: OffsetRange[] = []
+	let idx = 0
+	while (idx <= haystack.length - n.length) {
+		const found = haystack.indexOf(n, idx)
+		if (found === -1) break
+		out.push({ start: found, end: found + n.length })
+		idx = found + 1
+	}
+	return out
+}
+
+// Whitespace-insensitive overlap matching: treats any whitespace run in the quote as `\\s+` in the prompt.
+export function findAllOverlappingFlexible(haystack: string, needle: string): OffsetRange[] {
+	const raw = String(needle ?? '')
+	if (!raw.trim()) return []
+
+	const pattern = escapeRegex(raw).replace(/\s+/g, '\\s+')
+	let re: RegExp
+	try {
+		re = new RegExp(`(?=(${pattern}))`, 'gu')
+	} catch {
+		return []
+	}
+
+	const out: OffsetRange[] = []
+	let m: RegExpExecArray | null
+	while ((m = re.exec(haystack)) !== null) {
+		const start = m.index
+		const matched = m[1] ?? ''
+		const end = start + matched.length
+		if (end > start) out.push({ start, end })
+		if (re.lastIndex === start) re.lastIndex += 1
+	}
+	return out
+}
+
+export function buildNeedleVariants(raw: string): string[] {
+	const base = String(raw ?? '')
+	const trimmed = base.trim()
+	const variants = new Set<string>()
+	for (const v of [base, trimmed]) {
+		if (v) variants.add(v)
+	}
+
+	// Common "model-added" prefixes (bullets/numbering) that can break exact matching.
+	const noBullet = trimmed.replace(/^[-*•]\s+/, '')
+	if (noBullet && noBullet !== trimmed) variants.add(noBullet)
+	const noNumbering = trimmed.replace(/^(?:\(?\d+\)?[.)]|[a-zA-Z][.)])\s+/, '')
+	if (noNumbering && noNumbering !== trimmed) variants.add(noNumbering)
+
+	return [...variants].filter((v) => v.trim().length > 0)
+}
+
+// Length-preserving normalization for matching across punctuation variants.
+export function normalizeForMatching(text: string): string {
+	return String(text ?? '')
+		.replace(/\r/g, '\n')
+		.replace(/[\u00A0\u2007\u202F\u2009\u200A\u200B\uFEFF]/g, ' ')
+		.replace(/[\u201C\u201D\u201E\u00AB\u00BB]/g, '"')
+		.replace(/[\u2018\u2019]/g, "'")
+		.replace(/[\u2013\u2014]/g, '-')
+}
+
+export function escapeRegex(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/src/lib/monaco/bosun-theme.ts

@@ -0,0 +1,125 @@
+import type * as Monaco from 'monaco-editor'
+
+export interface PromptDecorations {
+	update: () => void
+	dispose: () => void
+}
+
+export function createPromptDecorations(
+	monaco: typeof Monaco,
+	editor: Monaco.editor.IStandaloneCodeEditor
+) {
+	const collection = editor.createDecorationsCollection()
+
+	function update() {
+		const model = editor.getModel()
+		if (!model) return
+
+		const decorations: Monaco.editor.IModelDeltaDecoration[] = []
+		const lineCount = model.getLineCount()
+
+		for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+			const lineText = model.getLineContent(lineNumber)
+
+			//  Headings
+			const match = /^(#+)\s/.exec(lineText)
+			if (match) {
+				const level = match[1].length
+				let cls = 'prompt-heading-3'
+
+				if (level === 1) {
+					cls = 'prompt-heading-1'
+				} else if (level === 2) {
+					cls = 'prompt-heading-2'
+				}
+
+				decorations.push({
+					range: new monaco.Range(lineNumber, 1, lineNumber, lineText.length + 1),
+					options: {
+						isWholeLine: true,
+						inlineClassName: cls
+					}
+				})
+			}
+
+			// Symbols '#' and '*'
+			for (let column = 1; column <= lineText.length; column++) {
+				const ch = lineText[column - 1]
+				if (ch === '#' || ch === '*') {
+					decorations.push({
+						range: new monaco.Range(lineNumber, column, lineNumber, column + 1),
+						options: {
+							inlineClassName: 'prompt-symbol'
+						}
+					})
+				}
+			}
+
+			// Subnumbers
+			const subMatch = lineText.match(/^(\s+)(\d+(?:\.\d+)+\.?)(?=[\s)]|$)/)
+			if (subMatch) {
+				const leading = subMatch[1]
+				const numberText = subMatch[2]
+
+				const startColumn = leading.length + 1
+				const endColumn = startColumn + numberText.length
+
+				decorations.push({
+					range: new monaco.Range(lineNumber, startColumn, lineNumber, endColumn),
+					options: {
+						inlineClassName: 'prompt-subnumber'
+					}
+				})
+			}
+		}
+
+		collection.set(decorations)
+	}
+
+	function dispose() {
+		collection.clear()
+	}
+
+	return { update, dispose }
+}
+
+export const bosunDarkTheme: Monaco.editor.IStandaloneThemeData = {
+	base: 'vs-dark',
+	inherit: true,
+	rules: [
+		// default text
+		{ token: '', foreground: 'DDDDDD' },
+		// keywords & others
+		{ token: 'string.md', foreground: 'DDDDDD' },
+		{ token: 'keyword.md', foreground: '767676' },
+		{ token: 'strong.md', foreground: 'DDDDDD', fontStyle: 'bold' },
+		{ token: 'string.target.md', foreground: '00B58A' },
+		{ token: 'tag.md', foreground: 'CE9178' },
+		{ token: 'string.link.md', foreground: '569cd6', fontStyle: 'underline' }
+	],
+	colors: {
+		// editor area
+		'editor.background': '#1D1D1D',
+		'editor.foreground': '#AFAFAF',
+
+		// (optional but nice to match)
+		'editorLineNumber.foreground': '#636363',
+		'editorLineNumber.activeForeground': '#767676',
+		'editorCursor.foreground': '#DDDDDD',
+		'editor.selectionBackground': '#4B5563D0',
+		'editor.inactiveSelectionBackground': '#4B5563A0',
+		'editor.lineHighlightBackground': '#FFFFFF08',
+		'editorLineNumber.background': '#1D1D1D',
+
+		// Nunjucks tag highlight (DocumentHighlightProvider)
+		'editor.wordHighlightBackground': '#ff480159'
+	}
+}
+
+let hasDefinedBosunTheme = false
+
+export function ensureBosunTheme(monaco: typeof Monaco) {
+	if (hasDefinedBosunTheme) return
+	monaco.editor.defineTheme('bosun-dark', bosunDarkTheme)
+	hasDefinedBosunTheme = true
+}

package/src/lib/monaco/font.ts

@@ -0,0 +1,2 @@
+export const MONACO_FONT_FAMILY =
+	'"Ubuntu Sans Mono", "PT Mono", "DM Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'

package/src/lib/monaco-workers.ts

@@ -0,0 +1,28 @@
+import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker'
+import CssWorker from 'monaco-editor/esm/vs/language/css/css.worker?worker'
+import HtmlWorker from 'monaco-editor/esm/vs/language/html/html.worker?worker'
+import JsonWorker from 'monaco-editor/esm/vs/language/json/json.worker?worker'
+import TsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker'
+
+export function ensureMonacoWorkers() {
+	if (typeof window === 'undefined') return
+
+	const env = (window as any).MonacoEnvironment as
+		| {
+				getWorker?: (moduleId: unknown, label: string) => Worker
+		  }
+		| undefined
+
+	if (env?.getWorker) return
+	;(window as any).MonacoEnvironment = {
+		...env,
+		getWorker: function (_moduleId: unknown, label: string) {
+			if (label === 'json') return new JsonWorker()
+			if (label === 'css' || label === 'scss' || label === 'less') return new CssWorker()
+			if (label === 'html' || label === 'handlebars' || label === 'razor') return new HtmlWorker()
+			if (label === 'typescript' || label === 'javascript') return new TsWorker()
+
+			return new EditorWorker()
+		}
+	}
+}

package/src/lib/steps.ts

@@ -0,0 +1,19 @@
+/**
+ * Recognises the name of an agent's primary conversational step. This is the single definition of
+ * that convention in Bosun — everywhere else should call this rather than test names inline, so the
+ * convention can change in one place.
+ *
+ * Projects name the step `main`, or `main[<anything>]` when they need several variants of it — for
+ * example one per region. **The bracket contents are opaque to Bosun.** What a project puts inside
+ * is its own business, so Bosun recognises the shape and never parses the inside. It follows that
+ * Bosun cannot tell which variant is "active"; where one has to be chosen, it simply takes the
+ * first match.
+ *
+ * `mainReply` is kept as a legacy alias for projects that used it.
+ */
+export function isMainStepName(name: string | null | undefined): boolean {
+	if (!name) return false
+	if (name === 'main' || name === 'mainReply') return true
+	// Require the bracket so unrelated names beginning with "main" (e.g. `maintenance`) don't match.
+	return name.startsWith('main[') && name.endsWith(']')
+}

package/src/lib/tests/pii-sanitized-test-draft.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod'
+
+export const TraceTestSeedSchema = z
+	.object({
+		pinned: z.literal('TRUE'),
+		step: z.string().optional(),
+		evaluation_mode: z.enum(['assertion', 'json-deep-equal']),
+		context_mode: z.literal('replace'),
+		assertion_type: z.literal('llm-rubric'),
+		assertion_value: z.string(),
+		conversation: z.string(),
+		expected_output: z.string(),
+		similarity_threshold: z.string(),
+		timeout: z.string(),
+		context: z.record(z.unknown()),
+		mocks: z.record(z.unknown()).optional()
+	})
+	.strict()
+
+export type TraceTestSeed = z.infer<typeof TraceTestSeedSchema>
+
+export const TraceTestReviewContentSchema = TraceTestSeedSchema.pick({
+	conversation: true,
+	expected_output: true,
+	context: true,
+	mocks: true
+}).strict()
+
+export type TraceTestReviewContent = z.infer<typeof TraceTestReviewContentSchema>
+
+export const PIIFindingCategorySchema = z.enum([
+	'person',
+	'contact',
+	'address',
+	'date_of_birth',
+	'account_identifier',
+	'vehicle_identifier',
+	'financial',
+	'special_category',
+	'other'
+])
+
+export const PIIFindingSchema = z
+	.object({
+		category: PIIFindingCategorySchema,
+		paths: z.array(z.string())
+	})
+	.strict()
+
+export type PIIFinding = z.infer<typeof PIIFindingSchema>

package/src/lib/trpc-client.ts

@@ -0,0 +1,16 @@
+import { env } from '$env/dynamic/public'
+import { createTRPCClient, httpLink } from '@trpc/client'
+import type { AppRouter } from '../backend/server'
+
+const trpcUrl =
+	env.PUBLIC_TRPC_URL ??
+	`http://${env.PUBLIC_TRPC_HOSTNAME ?? 'localhost'}:${env.PUBLIC_TRPC_PORT ?? '2022'}`
+
+// ref: https://github.com/trpc/trpc/blob/main/examples/standalone-server/src/client.ts
+export const trpc = createTRPCClient<AppRouter>({
+	links: [
+		httpLink({
+			url: trpcUrl
+		})
+	]
+})