ethagent 3.0.2 → 3.1.0

package/README.md

@@ -163,11 +163,16 @@ cd ethagent && npm install
 npm start
 ```
 
+The published CLI is source-distributed: `bin/ethagent.js` launches `src/cli/main.tsx` through `tsx`. `npm run build` is therefore a validation build; it checks the shipped TypeScript without producing a separate `dist/` directory.
+
+Repository structure and refactoring rules are documented in `ARCHITECTURE.md` and `CONTRIBUTING.md`. Stable facades keep public import paths intact while focused sibling modules hold private implementation details.
+
 | Command | What it does |
 | --- | --- |
 | `npm start` | Run from source. |
+| `npm run build` | Validate the shipped TypeScript source package. |
 | `npm test` | Test suite. |
-| `npm run typecheck` | Types. |
+| `npm run typecheck` | Run the same TypeScript check directly. |
 | `npm run contracts:test` | Foundry tests. |
 
 Foundry is only needed for `contracts/` changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethagent",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "A privacy-first AI agent with a portable Ethereum identity",
   "type": "module",
   "main": "bin/ethagent.js",
@@ -15,8 +15,10 @@
   ],
   "scripts": {
     "start": "node bin/ethagent.js",
+    "build": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
     "test": "node test/run-tests.mjs",
+    "prepack": "npm run build",
     "contracts:build": "cd contracts && forge build",
     "contracts:test": "cd contracts && forge test -vv",
     "contracts:fmt": "cd contracts && forge fmt"

package/src/app/FirstRun.tsx

@@ -26,6 +26,7 @@ import {
 import { setKey } from '../storage/secrets.js'
 import { IdentityHub, type IdentityHubResult } from '../identity/hub/IdentityHub.js'
 import { FirstRunTimeline, firstRunStageNumber, type FirstRunStepKind } from './FirstRunTimeline.js'
+import { configFromModelPickerSelection, formatGB } from './firstRunConfig.js'
 
 type Step =
   | { kind: 'detecting' }
@@ -568,27 +569,3 @@ export const FirstRun: React.FC<FirstRunProps> = ({ onComplete, onCancel }) => {
   return null
 }
 
-function configFromModelPickerSelection(selection: ModelPickerSelection, base: EthagentConfig): EthagentConfig {
-  if (selection.kind === 'llamacpp') {
-    return {
-      ...base,
-      provider: 'llamacpp',
-      model: selection.model,
-      baseUrl: defaultBaseUrlFor('llamacpp'),
-      localMmprojPath: selection.mmprojPath,
-    }
-  }
-  return {
-    ...base,
-    provider: selection.provider,
-    model: selection.model,
-    baseUrl: undefined,
-    localMmprojPath: undefined,
-  }
-}
-
-function formatGB(bytes: number): string {
-  const gb = bytes / (1024 * 1024 * 1024)
-  return gb < 10 ? `${gb.toFixed(1)}GB` : `${Math.round(gb)}GB`
-}
-

package/src/app/firstRunConfig.ts

@@ -0,0 +1,26 @@
+import { defaultBaseUrlFor, type EthagentConfig } from '../storage/config.js'
+import type { ModelPickerSelection } from '../models/ModelPicker.js'
+
+export function configFromModelPickerSelection(selection: ModelPickerSelection, base: EthagentConfig): EthagentConfig {
+  if (selection.kind === 'llamacpp') {
+    return {
+      ...base,
+      provider: 'llamacpp',
+      model: selection.model,
+      baseUrl: defaultBaseUrlFor('llamacpp'),
+      localMmprojPath: selection.mmprojPath,
+    }
+  }
+  return {
+    ...base,
+    provider: selection.provider,
+    model: selection.model,
+    baseUrl: undefined,
+    localMmprojPath: undefined,
+  }
+}
+
+export function formatGB(bytes: number): string {
+  const gb = bytes / (1024 * 1024 * 1024)
+  return gb < 10 ? `${gb.toFixed(1)}GB` : `${Math.round(gb)}GB`
+}

package/src/auth/openaiOAuth/landingPage.ts

@@ -1,22 +1,13 @@
 import { readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { transformSync } from 'esbuild'
 import { WALLET_CSS } from '../../identity/wallet/page/styles/index.js'
 import { glyphs } from '../../identity/wallet/page/html.js'
+import { walletPageSourceFile } from '../../identity/wallet/browserWallet/walletPageSource.js'
 import { escapeHtml } from './shared.js'
 
 export type LandingTone = 'success' | 'error' | 'cancelled'
 
-const GRAINIENT_SOURCE_FILE = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'identity',
-  'wallet',
-  'page',
-  'grainient.ts',
-)
+const GRAINIENT_SOURCE_FILE = walletPageSourceFile('page/grainient.ts')
 
 const COMPILED_GRAINIENT = compileGrainientModule()
 

package/src/chat/ChatScreen.tsx

@@ -1,6 +1,4 @@
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import os from 'node:os'
-import path from 'node:path'
 import { Box, Text, useApp } from 'ink'
 import type { EthagentConfig } from '../storage/config.js'
 import type { Provider, Message } from '../providers/contracts.js'
@@ -55,7 +53,6 @@ import type {
   PermissionRequest,
   SessionPermissionRule,
 } from '../tools/contracts.js'
-import { splitFileChangeResult } from '../tools/fileDiff.js'
 import {
   buildBaseMessages,
   sessionMessagesToRows,
@@ -74,12 +71,26 @@ import {
   restoreConversationState,
 } from './chatSessionState.js'
 import { runStreamingTurn } from './chatTurnOrchestrator.js'
-import { ensureLlamaCppRunnerReady } from '../models/llamacppPreflight.js'
 import type { PlanApprovalAction } from './views/PlanApprovalView.js'
 import type { ContextLimitAction } from './views/ContextLimitView.js'
 import type { ContinuityEditReviewAction, ContinuityEditReviewState } from './views/ContinuityEditReviewView.js'
 import { openFileInEditor } from '../identity/continuity/editor.js'
 import { EMPTY_MCP_SNAPSHOT, McpManager, type McpSnapshot } from '../mcp/manager.js'
+import { compressHome, ensureLocalProviderReady } from './chatEnvironment.js'
+import {
+  buildPlanImplementationPrompt,
+  buildPlanTransferSeedMessages,
+  chatFooterShortcutText,
+  normalizeHandoffSummary,
+} from './planImplementation.js'
+import { privateContinuityEditReviewFromToolResult } from './continuityEditReview.js'
+
+export {
+  buildPlanImplementationPrompt,
+  buildPlanTransferSeedMessages,
+  chatFooterShortcutText,
+} from './planImplementation.js'
+export { privateContinuityEditReviewFromToolResult } from './continuityEditReview.js'
 
 type ChatScreenProps = {
   config: EthagentConfig
@@ -114,19 +125,6 @@ const nowIso = (): string => new Date().toISOString()
 const STREAM_FLUSH_MS = 120
 const CONTEXT_CONFIRM_PERCENT = 90
 const MAX_PROMPT_HISTORY = 500
-const MAX_HANDOFF_SUMMARY_CHARS = 12_000
-
-function compressHome(cwd: string): string {
-  const home = os.homedir()
-  if (cwd === home) return '~'
-  if (cwd.startsWith(home + path.sep)) return '~' + cwd.slice(home.length).replace(/\\/g, '/')
-  return cwd.replace(/\\/g, '/')
-}
-
-async function ensureLocalProviderReady(config: EthagentConfig): Promise<{ ok: true } | { ok: false; message: string }> {
-  if (config.provider === 'llamacpp') return ensureLlamaCppRunnerReady(config)
-  return { ok: true }
-}
 
 export const ChatScreen: React.FC<ChatScreenProps> = ({ config: initialConfig, onReplaceConfig, updateNotice }) => {
   useRegisterKeybindingContext('Chat')
@@ -1640,113 +1638,14 @@ export const ChatScreen: React.FC<ChatScreenProps> = ({ config: initialConfig, o
   )
 }
 
-export function chatFooterShortcutText(canScrollTranscript: boolean): string {
-  return 'alt+p model · alt+i identity'
-}
-
 function formatContextLabel(usage: ContextUsage): string {
   if (!Number.isFinite(usage.usedTokens) || usage.usedTokens <= 0) return 'Estimated context: empty'
   return `Estimated context: ${usage.percent}% used`
 }
 
-export function buildPlanImplementationPrompt(plan: string): string {
-  return [
-    'Implement the approved plan below.',
-    '',
-    'Use native ethagent tools directly. Do not translate tool names into shell commands.',
-    'For workspace inspection, call list_directory and read_file directly.',
-    'For file creation or edits, call edit_file directly.',
-    'Use run_bash only for an actual shell command that cannot be performed by a narrower native tool, such as starting a local server after files exist.',
-    'Ignore any plan wording that says to execute file work as a Bash script or directly in the terminal; the native tools above are authoritative.',
-    'Read the relevant files before editing, make the required changes, and verify the result when possible.',
-    '',
-    plan,
-  ].join('\n')
-}
-
-export function buildPlanTransferSeedMessages(args: {
-  sourceSessionId: string
-  summary: string
-  plan: string
-  createdAt: string
-}): SessionMessage[] {
-  return [
-    {
-      role: 'user',
-      synthetic: true,
-      content: [
-        `Planning handoff from ${args.sourceSessionId.slice(0, 8)}:`,
-        '',
-        args.summary.trim(),
-      ].join('\n'),
-      createdAt: args.createdAt,
-    },
-    {
-      role: 'user',
-      synthetic: true,
-      content: [
-        'Approved plan to implement:',
-        '',
-        args.plan.trim(),
-      ].join('\n'),
-      createdAt: args.createdAt,
-    },
-  ]
-}
-
 function appendPromptHistoryEntry(history: string[], value: string): string[] {
   const prompt = value.trim()
   if (!prompt) return history
   const next = history[history.length - 1] === prompt ? history : [...history, prompt]
   return next.length > MAX_PROMPT_HISTORY ? next.slice(-MAX_PROMPT_HISTORY) : next
 }
-
-function normalizeHandoffSummary(summary: string): string {
-  const trimmed = summary.trim()
-  if (trimmed.length <= MAX_HANDOFF_SUMMARY_CHARS) return trimmed
-  return [
-    trimmed.slice(0, MAX_HANDOFF_SUMMARY_CHARS - 96).trimEnd(),
-    '',
-    '[handoff truncated to keep the resumed conversation responsive]',
-  ].join('\n')
-}
-
-export function privateContinuityEditReviewFromToolResult(
-  name: string,
-  input: Record<string, unknown>,
-  result: { ok: boolean; summary: string; content: string },
-): ContinuityEditReviewState | null {
-  if (name !== 'propose_private_continuity_edit' || !result.ok) return null
-  const file = normalizePrivateContinuityFile(input.file)
-  if (!file) return null
-  const parsed = splitFileChangeResult(result.content)
-  const filePath = extractReviewFilePath(parsed.content)
-  if (!filePath) return null
-  return {
-    file,
-    filePath,
-    summary: result.summary,
-    ...(parsed.diff ? { diff: parsed.diff } : {}),
-  }
-}
-
-function normalizePrivateContinuityFile(value: unknown): ContinuityEditReviewState['file'] | null {
-  if (typeof value !== 'string') return null
-  if (/^soul\.md$/i.test(value.trim())) return 'SOUL.md'
-  if (/^memory\.md$/i.test(value.trim())) return 'MEMORY.md'
-  return null
-}
-
-function extractReviewFilePath(content: string): string | null {
-  for (const line of content.split(/\r?\n/)) {
-    const review = line.match(/^(?:[-*]\s+)?review file:\s*(.+)$/i)
-    if (review?.[1]?.trim()) return cleanReviewFilePath(review[1])
-    const updated = line.match(/^(?:[-*]\s+)?updated local private continuity file\s+(.+)$/i)
-    if (updated?.[1]?.trim()) return cleanReviewFilePath(updated[1])
-  }
-  return null
-}
-
-function cleanReviewFilePath(value: string): string {
-  return value.trim().replace(/^`+|`+$/g, '').trim()
-}

package/src/chat/MessageList.tsx

@@ -8,6 +8,18 @@ import { SyntaxLine } from './display/SyntaxText.js'
 import { formatToolCall } from './display/toolCallDisplay.js'
 import { BrandSplash } from '../ui/BrandSplash.js'
 import type { RowSlice } from './transcript/transcriptViewport.js'
+import {
+  blockContentWidth,
+  clipTextForDisplay,
+  parseInlineTokens,
+  parseMarkdownBlocks,
+  sanitizeReasoningForDisplay,
+  summarizeThinking,
+  type InlineToken,
+  type MarkdownBlock,
+} from './messageMarkdown.js'
+
+export { sanitizeReasoningForDisplay } from './messageMarkdown.js'
 
 export type ToolCallResult = {
   content: string
@@ -52,28 +64,17 @@ type MessageListProps = {
   slices: Array<RowSlice<MessageRow>>
 }
 
-export function rowsToFullSlices(rows: MessageRow[]): Array<RowSlice<MessageRow>> {
-  return rows.map(row => ({ row, clipStart: 0, clipEnd: Number.MAX_SAFE_INTEGER, rowHeight: Number.MAX_SAFE_INTEGER }))
-}
-
-type MarkdownBlock =
-  | { kind: 'heading'; level: 1 | 2 | 3 | 4 | 5 | 6; text: string }
-  | { kind: 'paragraph'; text: string }
-  | { kind: 'quote'; lines: string[] }
-  | { kind: 'list'; ordered: boolean; items: string[] }
-  | { kind: 'code'; lang: string | null; code: string; open?: boolean }
-
-type InlineToken =
-  | { kind: 'text'; text: string }
-  | { kind: 'bold'; text: string }
-  | { kind: 'italic'; text: string }
-  | { kind: 'code'; text: string }
+export {
+  rowsToFullSlices,
+  toggleInspectableRow,
+  toggleLatestReasoningRow,
+  toggleReasoningRow,
+} from './messageRows.js'
 
 const MAX_RENDERED_MESSAGE_CHARS = 12_000
 const MAX_RENDERED_REASONING_CHARS = 10_000
 const ASSISTANT_ACCENT = theme.accentPeriwinkle
 const ASSISTANT_MARKER = '• '
-const UNREADABLE_REASONING_TEXT = 'reasoning output was not readable text'
 
 const MessageListInner: React.FC<MessageListProps> = ({ slices }) => (
   <Box flexDirection="column">
@@ -89,43 +90,6 @@ const MessageListInner: React.FC<MessageListProps> = ({ slices }) => (
 
 export const MessageList = React.memo(MessageListInner)
 
-function isInspectableRole(role: MessageRow['role']): boolean {
-  return role === 'thinking'
-}
-
-export function toggleLatestReasoningRow(rows: MessageRow[]): MessageRow[] {
-  return toggleInspectableRow(rows)
-}
-
-export function toggleReasoningRow(rows: MessageRow[], rowId?: string): MessageRow[] {
-  return toggleInspectableRow(rows, rowId)
-}
-
-export function toggleInspectableRow(rows: MessageRow[], rowId?: string): MessageRow[] {
-  let index = -1
-  if (rowId) {
-    index = rows.findIndex(row => row.id === rowId && isInspectableRole(row.role))
-  }
-  if (index === -1) {
-    for (let cursor = rows.length - 1; cursor >= 0; cursor -= 1) {
-      const role = rows[cursor]?.role
-      if (role && isInspectableRole(role)) {
-        index = cursor
-        break
-      }
-    }
-  }
-  if (index === -1) return rows
-  const row = rows[index]
-  if (!row) return rows
-  if (row.role === 'thinking') {
-    const next = rows.slice()
-    next[index] = { ...row, expanded: !row.expanded }
-    return next
-  }
-  return rows
-}
-
 const RowViewInner: React.FC<{ slice: RowSlice<MessageRow>; tightTop?: boolean }> = ({ slice, tightTop }) => {
   const { row, clipStart, clipEnd, rowHeight } = slice
   if (row.role === 'user') {
@@ -669,212 +633,6 @@ const StreamCursor: React.FC<{ active: boolean }> = ({ active }) => {
   return <>{visible ? '|' : ' '}</>
 }
 
-function blockContentWidth(lines: string[]): number {
-  return Math.max(1, ...lines.map(displayWidth))
-}
-
-function displayWidth(line: string): number {
-  return (line || ' ').replace(/\t/g, '  ').length
-}
-
-function parseMarkdownBlocks(markdown: string): MarkdownBlock[] {
-  const text = markdown.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
-  if (!text.trim()) return []
-
-  const blocks: MarkdownBlock[] = []
-  const lines = text.split('\n')
-  let index = 0
-
-  while (index < lines.length) {
-    const line = lines[index] ?? ''
-    const trimmed = line.trim()
-
-    if (!trimmed) {
-      index += 1
-      continue
-    }
-
-    const fence = trimmed.match(/^```([\w+-]*)\s*$/)
-    if (fence) {
-      const lang = fence[1] && fence[1].length > 0 ? fence[1] : null
-      index += 1
-      const body: string[] = []
-      let closed = false
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        if (nextLine.trim().match(/^```\s*$/)) {
-          closed = true
-          index += 1
-          break
-        }
-        body.push(nextLine)
-        index += 1
-      }
-      blocks.push({ kind: 'code', lang, code: body.join('\n'), open: !closed })
-      continue
-    }
-
-    const heading = line.match(/^(#{1,6})\s+(.*)$/)
-    if (heading) {
-      const [, hashes = '#', headingText = ''] = heading
-      blocks.push({
-        kind: 'heading',
-        level: hashes.length as 1 | 2 | 3 | 4 | 5 | 6,
-        text: headingText.trim(),
-      })
-      index += 1
-      continue
-    }
-
-    if (/^>\s?/.test(trimmed)) {
-      const quoteLines: string[] = []
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        if (!/^>\s?/.test(nextLine.trim())) break
-        quoteLines.push(nextLine.trim().replace(/^>\s?/, ''))
-        index += 1
-      }
-      blocks.push({ kind: 'quote', lines: quoteLines })
-      continue
-    }
-
-    const ordered = trimmed.match(/^\d+\.\s+(.*)$/)
-    const unordered = trimmed.match(/^[-*+]\s+(.*)$/)
-    if (ordered || unordered) {
-      const items: string[] = []
-      const orderedList = Boolean(ordered)
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        const match = orderedList
-          ? nextLine.trim().match(/^\d+\.\s+(.*)$/)
-          : nextLine.trim().match(/^[-*+]\s+(.*)$/)
-        if (!match) break
-        items.push(match[1] ?? '')
-        index += 1
-      }
-      blocks.push({ kind: 'list', ordered: orderedList, items })
-      continue
-    }
-
-    const paragraph: string[] = []
-    while (index < lines.length) {
-      const nextLine = lines[index] ?? ''
-      const nextTrimmed = nextLine.trim()
-      if (!nextTrimmed) break
-      if (nextTrimmed.match(/^```([\w+-]*)\s*$/)) break
-      if (nextLine.match(/^(#{1,6})\s+(.*)$/)) break
-      if (/^>\s?/.test(nextTrimmed)) break
-      if (nextTrimmed.match(/^\d+\.\s+(.*)$/) || nextTrimmed.match(/^[-*+]\s+(.*)$/)) break
-      paragraph.push(nextLine)
-      index += 1
-    }
-    blocks.push({ kind: 'paragraph', text: paragraph.join('\n').trim() })
-  }
-
-  return blocks
-}
-
-function parseInlineTokens(text: string): InlineToken[] {
-  const tokens: InlineToken[] = []
-  const source = normalizeInlineDisplayText(text)
-  const pattern = /(`[^`\n]+`|\*\*[^*\n]+?\*\*|__[^_\n]+?__|\*[^*\n]+?\*|_[^_\n]+?_)/g
-  let lastIndex = 0
-  let match: RegExpExecArray | null
-
-  while ((match = pattern.exec(source)) !== null) {
-    if (match.index > lastIndex) {
-      tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex, match.index)) })
-    }
-
-    const token = match[0]
-    if ((token.startsWith('**') && token.endsWith('**')) || (token.startsWith('__') && token.endsWith('__'))) {
-      tokens.push({ kind: 'bold', text: cleanPlainInlineText(token.slice(2, -2)) })
-    } else if ((token.startsWith('*') && token.endsWith('*')) || (token.startsWith('_') && token.endsWith('_'))) {
-      tokens.push({ kind: 'italic', text: cleanPlainInlineText(token.slice(1, -1)) })
-    } else if (token.startsWith('`') && token.endsWith('`')) {
-      tokens.push({ kind: 'code', text: token.slice(1, -1) })
-    }
-
-    lastIndex = match.index + token.length
-  }
-
-  if (lastIndex < source.length || tokens.length === 0) {
-    tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex)) })
-  }
-
-  return tokens.filter(token => token.text.length > 0)
-}
-
-function normalizeInlineDisplayText(text: string): string {
-  return text
-    .replace(/\\\(/g, '')
-    .replace(/\\\)/g, '')
-    .replace(/\\\[/g, '')
-    .replace(/\\\]/g, '')
-    .replace(/\$\$([^$]+)\$\$/g, '$1')
-    .replace(/\$([^$\n]+)\$/g, '$1')
-    .replace(/\\([{}[\]()])/g, '$1')
-    .replace(/\/([{}])/g, '$1')
-}
-
-function cleanPlainInlineText(text: string): string {
-  return text.replace(/\*+/g, '')
-}
-
-function summarizeThinking(text: string): string {
-  const sample = text.length > 1000 ? text.slice(-1000) : text
-  const normalized = sample.replace(/\s+/g, ' ').trim()
-  if (!normalized) return ''
-  const prefix = text.length > sample.length ? '...' : ''
-  if (normalized.length + prefix.length <= 120) return `${prefix}${normalized}`
-  return `${prefix}${normalized.slice(Math.max(0, normalized.length - (120 - prefix.length)))}`
-}
-
-function clipTextForDisplay(text: string, maxChars: number): { text: string; omittedChars: number } {
-  if (text.length <= maxChars) return { text, omittedChars: 0 }
-  const rawStart = Math.max(0, text.length - maxChars)
-  const newline = text.indexOf('\n', rawStart)
-  const start = newline >= 0 && newline - rawStart <= 240 ? newline + 1 : rawStart
-  return {
-    text: text.slice(start),
-    omittedChars: start,
-  }
-}
-
 function reasoningText(row: Extract<MessageRow, { role: 'thinking' }>): string {
   return row.liveTail ? row.content + row.liveTail : row.content
 }
-
-export function sanitizeReasoningForDisplay(text: string): string {
-  const normalized = text
-    .replace(/\r\n/g, '\n')
-    .replace(/\r/g, '\n')
-    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')
-  const controlCount = countMatches(normalized, /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g)
-  const cleaned = normalized
-    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g, '')
-    .replace(/\t/g, '  ')
-  const visibleLength = cleaned.replace(/\s/g, '').length
-  if (visibleLength === 0) return ''
-  if (controlCount > 0 && controlCount / Math.max(1, text.length) > 0.05) return UNREADABLE_REASONING_TEXT
-  if (looksLikeUnreadableReasoning(cleaned)) return UNREADABLE_REASONING_TEXT
-  return cleaned
-}
-
-function looksLikeUnreadableReasoning(text: string): boolean {
-  const visible = text.replace(/\s/g, '')
-  if (visible.length < 120) return false
-  const letters = countMatches(visible, /[A-Za-z]/g)
-  const digits = countMatches(visible, /\d/g)
-  const words = text.match(/[A-Za-z]{3,}/g) ?? []
-  const wordChars = words.reduce((sum, word) => sum + word.length, 0)
-  const whitespace = countMatches(text, /\s/g)
-  const symbolDensity = (visible.length - letters - digits) / visible.length
-  const wordDensity = wordChars / visible.length
-  const whitespaceDensity = whitespace / Math.max(1, text.length)
-  return symbolDensity > 0.38 && wordDensity < 0.32 && whitespaceDensity < 0.12
-}
-
-function countMatches(text: string, pattern: RegExp): number {
-  return text.match(pattern)?.length ?? 0
-}

package/src/chat/chatEnvironment.ts

@@ -0,0 +1,16 @@
+import os from 'node:os'
+import path from 'node:path'
+import type { EthagentConfig } from '../storage/config.js'
+import { ensureLlamaCppRunnerReady } from '../models/llamacppPreflight.js'
+
+export function compressHome(cwd: string): string {
+  const home = os.homedir()
+  if (cwd === home) return '~'
+  if (cwd.startsWith(home + path.sep)) return '~' + cwd.slice(home.length).replace(/\\/g, '/')
+  return cwd.replace(/\\/g, '/')
+}
+
+export async function ensureLocalProviderReady(config: EthagentConfig): Promise<{ ok: true } | { ok: false; message: string }> {
+  if (config.provider === 'llamacpp') return ensureLlamaCppRunnerReady(config)
+  return { ok: true }
+}

package/src/chat/chatTurnContext.ts

@@ -0,0 +1,50 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import type { Message } from '../providers/contracts.js'
+
+export async function buildFileMentionContextMessages(
+  userText: string,
+  cwd: string,
+): Promise<Message[]> {
+  const mentions = extractFileMentions(userText)
+  if (mentions.length === 0) return []
+
+  const lines: string[] = []
+  for (const mention of mentions) {
+    const resolved = path.resolve(cwd, mention)
+    const rel = path.relative(cwd, resolved)
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+      lines.push(
+        `@${mention} -> outside current workspace; do not use unless the user changes directory or names an allowed path.`,
+      )
+      continue
+    }
+    try {
+      const stats = await fs.stat(resolved)
+      lines.push(`@${mention} -> ${mention} (${stats.isDirectory() ? 'directory' : 'file'})`)
+    } catch {
+      lines.push(`@${mention} -> unresolved`)
+    }
+  }
+
+  return [
+    {
+      role: 'user',
+      content: [
+        'Resolved file mentions for this request:',
+        ...lines,
+        'Treat these mentions as authoritative filenames from the user request. Read referenced context files when needed, and edit only the file requested by the user or the target file you have inspected.',
+      ].join('\n'),
+    },
+  ]
+}
+
+function extractFileMentions(text: string): string[] {
+  const mentions = new Set<string>()
+  for (const match of text.matchAll(/@([^\s]+)/g)) {
+    const raw = match[1]?.replace(/[),.;:!?]+$/g, '')
+    if (!raw || raw.length === 0) continue
+    mentions.add(raw.replace(/\\/g, '/'))
+  }
+  return [...mentions]
+}