@wingsbutterfly/dsh-rtk 0.1.0

package/src/command.ts

@@ -0,0 +1,174 @@
+import type { RtkConfig } from './config.js'
+import type { MetricsSummary } from './metrics.js'
+import type { RtkRuntimeStatus } from './runtime-guard.js'
+
+/** Everything the `/rtk` command needs from the plugin. */
+export interface RtkCommandController {
+  getConfig(): RtkConfig
+  /** Replace the user layer wholesale; `{}` restores composition defaults. */
+  resetConfig(): Promise<void>
+  getRuntimeStatus(): RtkRuntimeStatus
+  refreshRuntimeStatus(): Promise<RtkRuntimeStatus>
+  getMetrics(): MetricsSummary
+  clearMetrics(): void
+  /** Where the user layer of the configuration lives, when it is persisted. */
+  configLocation(): string
+}
+
+/** The command result shape the harness normalizes. */
+export type RtkCommandResult = { kind: 'success'; text?: string } | { kind: 'error'; text: string }
+
+/**
+ * Official install routes, taken from the project's own README.
+ *
+ * `cargo install rtk` is called out because crates.io carries an unrelated
+ * crate of the same name; only the `--git` form installs this tool.
+ */
+const INSTALL_HINT = [
+  'Install rtk with one of:',
+  '  brew install rtk                        # macOS / Linux (Homebrew, recommended)',
+  '  winget install rtk-ai.rtk               # Windows',
+  '  curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh',
+  '  cargo install --git https://github.com/rtk-ai/rtk',
+  '',
+  'Note: plain `cargo install rtk` installs an unrelated crate of the same name.',
+  'Releases: https://github.com/rtk-ai/rtk/releases',
+].join('\n')
+
+const HELP_TEXT = [
+  'dsh-rtk — rewrite bash commands to rtk and compact tool output.',
+  '',
+  '  /rtk              show configuration and runtime status',
+  '  /rtk show         same as /rtk',
+  '  /rtk path         where the configuration is stored',
+  '  /rtk verify       check whether the rtk executable is usable (prints install options when it is not)',
+  '  /rtk stats        compaction savings for this session',
+  '  /rtk clear-stats  reset the savings counters',
+  '  /rtk reset        restore configuration defaults',
+  '  /rtk help         this text',
+].join('\n')
+
+function yesNo(value: boolean): string {
+  return value ? 'on' : 'off'
+}
+
+function configReport(config: RtkConfig, status: RtkRuntimeStatus, location: string): string {
+  const compaction = config.outputCompaction
+  const lines = [
+    `dsh-rtk: ${yesNo(config.enabled)}   mode: ${config.mode}`,
+    `rtk binary: ${status.rtkAvailable ? 'available' : 'unavailable'}${status.rtkExecutablePath ? ` (${status.rtkExecutablePath})` : ''}`,
+    `config: ${location}`,
+    '',
+    'command rewriting',
+    `  guardWhenRtkMissing      ${yesNo(config.guardWhenRtkMissing)}`,
+    `  showRewriteNotifications ${yesNo(config.showRewriteNotifications)}`,
+    `  rewriteTimeoutMs         ${config.rewriteTimeoutMs}`,
+    '',
+    'output compaction',
+    `  enabled                  ${yesNo(compaction.enabled)}`,
+    `  tools                    ${config.compactedTools.join(', ')}`,
+    `  stripAnsi                ${yesNo(compaction.stripAnsi)}`,
+    `  readCompaction           ${yesNo(compaction.readCompaction.enabled)}`,
+    `  sourceCodeFiltering      ${compaction.sourceCodeFiltering}`,
+    `  filterBuildOutput        ${yesNo(compaction.filterBuildOutput)}`,
+    `  aggregateTestOutput      ${yesNo(compaction.aggregateTestOutput)}`,
+    `  compactGitOutput         ${yesNo(compaction.compactGitOutput)}`,
+    `  aggregateLinterOutput    ${yesNo(compaction.aggregateLinterOutput)}`,
+    `  groupSearchOutput        ${yesNo(compaction.groupSearchOutput)}`,
+    `  smartTruncate            ${yesNo(compaction.smartTruncate.enabled)} (max ${compaction.smartTruncate.maxLines} lines)`,
+    `  truncate                 ${yesNo(compaction.truncate.enabled)} (max ${compaction.truncate.maxChars} chars)`,
+  ]
+  if (status.lastError) lines.push('', `last rtk error: ${status.lastError}`)
+  return lines.join('\n')
+}
+
+function statsReport(summary: MetricsSummary): string {
+  if (summary.calls === 0) return 'dsh-rtk: no compaction recorded in this session yet.'
+
+  const lines = [
+    `compacted calls: ${summary.calls}`,
+    `characters: ${summary.originalChars} -> ${summary.compactedChars} (saved ${summary.savedChars}, ${summary.savedPercent}%)`,
+  ]
+
+  const tools = Object.entries(summary.byTool)
+  if (tools.length > 0) {
+    lines.push('', 'by tool:')
+    for (const [tool, totals] of tools.sort((left, right) => right[1].originalChars - left[1].originalChars)) {
+      const saved = Math.max(0, totals.originalChars - totals.compactedChars)
+      lines.push(`  ${tool}: ${totals.calls} call(s), saved ${saved} chars`)
+    }
+  }
+
+  const techniques = Object.entries(summary.byTechnique)
+  if (techniques.length > 0) {
+    lines.push('', 'techniques:')
+    for (const [technique, count] of techniques.sort((left, right) => right[1] - left[1])) {
+      lines.push(`  ${technique}: ${count}`)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Build the `/rtk` command definition.
+ *
+ * The harness has no interactive settings modal, so every subcommand returns
+ * text; the configuration itself is editable through the harness settings
+ * document, which this namespace is registered in.
+ *
+ * @param controller - accessors into the live plugin state.
+ * @returns the command definition to register.
+ */
+export function createRtkCommand(controller: RtkCommandController): {
+  name: string
+  description: string
+  handler: (invocation: { rawInput: string }) => Promise<RtkCommandResult>
+} {
+  return {
+    name: 'rtk',
+    description: 'RTK command rewriting and output compaction: status, verification, and savings.',
+    async handler(invocation) {
+      const subcommand = invocation.rawInput.trim().split(/\s+/)[0]?.toLowerCase() ?? ''
+
+      switch (subcommand) {
+        case '':
+        case 'show':
+          return { kind: 'success', text: configReport(controller.getConfig(), controller.getRuntimeStatus(), controller.configLocation()) }
+
+        case 'path':
+          return { kind: 'success', text: controller.configLocation() }
+
+        case 'verify': {
+          const status = await controller.refreshRuntimeStatus()
+          if (status.rtkAvailable) {
+            const parts = [`rtk is available at ${status.rtkExecutablePath ?? status.rtkExecutableCommand ?? 'rtk'}`]
+            if (status.rtkExecutableResolutionWarning) parts.push(`note: ${status.rtkExecutableResolutionWarning}`)
+            return { kind: 'success', text: parts.join('\n') }
+          }
+          return {
+            kind: 'error',
+            text: `rtk is not usable: ${status.lastError ?? 'unknown error'}\n\n${INSTALL_HINT}`,
+          }
+        }
+
+        case 'stats':
+          return { kind: 'success', text: statsReport(controller.getMetrics()) }
+
+        case 'clear-stats':
+          controller.clearMetrics()
+          return { kind: 'success', text: 'dsh-rtk: savings counters cleared.' }
+
+        case 'reset':
+          await controller.resetConfig()
+          return { kind: 'success', text: 'dsh-rtk: configuration restored to defaults.' }
+
+        case 'help':
+          return { kind: 'success', text: HELP_TEXT }
+
+        default:
+          return { kind: 'error', text: `unknown subcommand "${subcommand}".\n\n${HELP_TEXT}` }
+      }
+    },
+  }
+}

package/src/compact/build.ts

@@ -0,0 +1,154 @@
+import { matchesCommandPatterns } from './detect.js'
+
+interface BuildStats {
+  compiled: number
+  errors: string[][]
+  warnings: string[]
+}
+
+const BUILD_COMMAND_PATTERNS = [
+  /^cargo\s+(build|check)\b/,
+  /^bun\s+build\b/,
+  /^npm\s+run\s+build\b/,
+  /^yarn\s+build\b/,
+  /^pnpm\s+build\b/,
+  /^(?:npx\s+)?tsc\b/,
+  /^make\b/,
+  /^cmake\b/,
+  /^gradle\b/,
+  /^mvn\b/,
+  /^go\s+(build|install)\b/,
+  /^python\s+setup\.py\s+build\b/,
+  /^pip\s+install\b/,
+] as const
+
+/** Progress chatter that carries no actionable information. */
+const SKIP_PATTERNS = [
+  /^\s*Compiling\s+/,
+  /^\s*Checking\s+/,
+  /^\s*Downloading\s+/,
+  /^\s*Downloaded\s+/,
+  /^\s*Fetching\s+/,
+  /^\s*Fetched\s+/,
+  /^\s*Updating\s+/,
+  /^\s*Updated\s+/,
+  /^\s*Building\s+/,
+  /^\s*Generated\s+/,
+  /^\s*Creating\s+/,
+  /^\s*Running\s+/,
+]
+
+const ERROR_START_PATTERNS = [
+  /^error\[/,
+  /^error:/,
+  /^\[ERROR\]/,
+  /^FAIL/,
+  // `tsc` and friends: `path(line,col): error TSxxxx: message`.
+  /^[^\s:][^:]*(?:\(\d+[,:]\d+\)|:\d+:\d+):\s*(?:fatal\s+)?error\b/,
+  // The `path:line:col: error: message` shape used by many linters and compilers.
+  /^[^\s:][^:]*:\d+:\s*(?:fatal\s+)?error\b/,
+]
+const WARNING_PATTERNS = [/^warning:/, /^\[WARNING\]/, /^warn:/]
+const COMPILE_PROGRESS_PATTERN = /^\s*(Compiling|Checking|Building)\s+/
+
+const MAX_ERRORS = 5
+const MAX_ERROR_LINES = 10
+const BLANKS_TO_CLOSE_BLOCK = 2
+
+function isSkipLine(line: string): boolean {
+  return SKIP_PATTERNS.some((pattern) => pattern.test(line))
+}
+
+/**
+ * Reduce compiler output to its errors and warnings.
+ *
+ * Errors keep their indented continuation lines (the source excerpt and the
+ * `-->` location) because that detail is what makes an error actionable;
+ * progress lines and everything else are dropped. A build with no diagnostics
+ * collapses to a one-line success marker, which is the common case and the
+ * largest saving.
+ *
+ * @param output - raw build output.
+ * @param command - the command that produced it; drives the applicability check.
+ * @returns the summary, or `null` when the command is not a build command.
+ */
+export function filterBuildOutput(output: string, command: string | undefined | null): string | null {
+  if (!matchesCommandPatterns(command, BUILD_COMMAND_PATTERNS)) return null
+
+  const lines = output.split('\n')
+  const stats: BuildStats = { compiled: 0, errors: [], warnings: [] }
+
+  let inErrorBlock = false
+  let currentError: string[] = []
+  let blankCount = 0
+
+  for (const line of lines) {
+    if (COMPILE_PROGRESS_PATTERN.test(line)) {
+      stats.compiled++
+      continue
+    }
+    if (isSkipLine(line)) continue
+
+    if (ERROR_START_PATTERNS.some((pattern) => pattern.test(line))) {
+      if (inErrorBlock && currentError.length > 0) stats.errors.push([...currentError])
+      inErrorBlock = true
+      currentError = [line]
+      blankCount = 0
+      continue
+    }
+
+    if (WARNING_PATTERNS.some((pattern) => pattern.test(line))) {
+      stats.warnings.push(line)
+      continue
+    }
+
+    if (!inErrorBlock) continue
+
+    if (line.trim() === '') {
+      blankCount++
+      if (blankCount >= BLANKS_TO_CLOSE_BLOCK && currentError.length > 3) {
+        stats.errors.push([...currentError])
+        inErrorBlock = false
+        currentError = []
+      } else {
+        currentError.push(line)
+      }
+      continue
+    }
+
+    if (line.match(/^\s/) || line.match(/^-->/)) {
+      currentError.push(line)
+      blankCount = 0
+      continue
+    }
+
+    stats.errors.push([...currentError])
+    inErrorBlock = false
+    currentError = []
+  }
+
+  if (inErrorBlock && currentError.length > 0) stats.errors.push(currentError)
+
+  if (stats.errors.length === 0 && stats.warnings.length === 0) {
+    // Success may only be claimed on positive evidence that the build ran and
+    // was clean. With no diagnostics AND no progress lines the parser simply
+    // did not understand the output — and it cannot see an exit code, so
+    // guessing "success" would replace a real compiler failure with a
+    // reassuring lie. Declining to summarize leaves the text intact.
+    if (stats.compiled === 0) return null
+    return `[OK] Build successful (${stats.compiled} units compiled)`
+  }
+
+  const result: string[] = []
+  if (stats.errors.length > 0) {
+    result.push(`[ERROR] ${stats.errors.length} error(s):`)
+    for (const error of stats.errors.slice(0, MAX_ERRORS)) {
+      result.push(...error.slice(0, MAX_ERROR_LINES))
+      if (error.length > MAX_ERROR_LINES) result.push('  ...')
+    }
+    if (stats.errors.length > MAX_ERRORS) result.push(`... and ${stats.errors.length - MAX_ERRORS} more errors`)
+  }
+  if (stats.warnings.length > 0) result.push(`\n[WARN] ${stats.warnings.length} warning(s)`)
+
+  return result.join('\n')
+}

package/src/compact/detect.ts

@@ -0,0 +1,54 @@
+/**
+ * Command classification helpers.
+ *
+ * Every technique asks the same question first — "is this the kind of command
+ * whose output I know how to summarize?" — so the normalization lives here
+ * rather than being repeated (and drifting) per technique.
+ */
+
+const ENV_PREFIX_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)*/
+const CHAIN_OPERATORS = ['&&', '||', ';', '|'] as const
+
+function sliceFirstSegment(command: string): string {
+  let cutIndex = -1
+  for (const operator of CHAIN_OPERATORS) {
+    const index = command.indexOf(operator)
+    if (index === -1) continue
+    if (cutIndex === -1 || index < cutIndex) cutIndex = index
+  }
+  return cutIndex === -1 ? command : command.slice(0, cutIndex)
+}
+
+/**
+ * Reduce a command line to its first simple command, lower-cased.
+ *
+ * `FOO=1 git status | head` normalizes to `git status`: the assignment run is
+ * not the command, and the pipeline is not part of what the first command is.
+ * A pattern that matches the whole line would classify every prefixed or
+ * piped invocation as unknown and skip compaction entirely.
+ *
+ * @param command - raw command line, possibly multi-line.
+ * @returns the normalized first command, or `null` when there is none.
+ */
+export function normalizeCommandForDetection(command: string | undefined | null): string | null {
+  if (typeof command !== 'string') return null
+
+  const firstNonEmptyLine = command
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0)
+  if (!firstNonEmptyLine) return null
+
+  const withoutEnvPrefix = firstNonEmptyLine.replace(ENV_PREFIX_PATTERN, '').trim()
+  if (!withoutEnvPrefix) return null
+
+  const firstSegment = sliceFirstSegment(withoutEnvPrefix).trim().toLowerCase()
+  return firstSegment || null
+}
+
+/** Whether the command's first simple command matches any pattern. */
+export function matchesCommandPatterns(command: string | undefined | null, patterns: readonly RegExp[]): boolean {
+  const normalized = normalizeCommandForDetection(command)
+  if (!normalized) return false
+  return patterns.some((pattern) => pattern.test(normalized))
+}

package/src/compact/dsh-result.ts

@@ -0,0 +1,99 @@
+/**
+ * Split and reassemble the harness `bash` result envelope.
+ *
+ * The bash tool renders a result as the stdout tail, an optional `[stderr]`
+ * section, and a run of trailing status markers (`[exit code: N]`,
+ * `[timed out after …]`, `[sandbox: …]`, …). Those markers are load-bearing:
+ * the model is told to check `[exit code: N]` on every call, and the Web UI
+ * parses that same line to draw its exit-status pill.
+ *
+ * Compaction rewrites the output body, so anything that rebuilds the text
+ * wholesale — the git, build, and test summarizers all do — would drop the
+ * markers with it. This module is the boundary that keeps that from happening:
+ * markers are lifted out before compaction and put back after, in their
+ * original order.
+ */
+
+/** Markers the bash tool appends after the output body. */
+const TRAILING_MARKER_PATTERNS = [
+  /^\[exit code: -?\d+\]$/,
+  /^\[killed by signal: .+\]$/,
+  /^\[timed out after \d+ms\]$/,
+  /^\[output truncated; full output: .+\]$/,
+  /^\[some output was dropped from memory; full output: .+\]$/,
+  /^\[sandbox: .+\]$/,
+] as const
+
+const STDERR_HEADER = '[stderr]'
+/** The bash tool's placeholder for a command that printed nothing at all. */
+export const NO_OUTPUT_PLACEHOLDER = '(no output)'
+
+function isTrailingMarker(line: string): boolean {
+  return TRAILING_MARKER_PATTERNS.some((pattern) => pattern.test(line))
+}
+
+/** A bash result decomposed into the parts compaction must treat differently. */
+export interface BashResultParts {
+  /** True when the tool rendered its "printed nothing" placeholder. */
+  empty: boolean
+  /** stdout body, without the `[stderr]` section or trailing markers. */
+  stdout: string
+  /** stderr body when the result carried a `[stderr]` section. */
+  stderr?: string
+  /** Trailing status markers, in their original order. */
+  markers: string[]
+}
+
+/**
+ * Decompose a rendered bash result.
+ *
+ * Trailing markers are peeled from the end first, then the `[stderr]` section
+ * is split off. Only the first `[stderr]` header counts: if the command's own
+ * output contains that literal line, everything after it belongs to stderr,
+ * which is what the renderer produced.
+ *
+ * @param text - the rendered bash result.
+ * @returns the decomposed parts.
+ */
+export function parseBashResult(text: string): BashResultParts {
+  if (text === NO_OUTPUT_PLACEHOLDER) {
+    return { empty: true, stdout: '', markers: [] }
+  }
+
+  const lines = text.split('\n')
+  const markers: string[] = []
+  while (lines.length > 0) {
+    const last = lines[lines.length - 1]
+    if (last === undefined || !isTrailingMarker(last)) break
+    markers.unshift(last)
+    lines.pop()
+  }
+
+  const headerIndex = lines.indexOf(STDERR_HEADER)
+  if (headerIndex === -1) {
+    return { empty: false, stdout: lines.join('\n'), markers }
+  }
+
+  const stdout = lines.slice(0, headerIndex).join('\n')
+  const stderr = lines.slice(headerIndex + 1).join('\n')
+  return { empty: false, stdout, stderr, markers }
+}
+
+/**
+ * Reassemble a bash result from its parts.
+ *
+ * The inverse of {@link parseBashResult}, so the model-visible contract — the
+ * marker lines the agent loop and the UI both depend on — survives a
+ * compaction pass untouched.
+ */
+export function renderBashResult(parts: BashResultParts): string {
+  const sections: string[] = []
+  if (parts.empty) {
+    sections.push(NO_OUTPUT_PLACEHOLDER)
+  } else {
+    if (parts.stdout.length > 0) sections.push(parts.stdout)
+    if (parts.stderr !== undefined) sections.push(STDERR_HEADER, parts.stderr)
+  }
+  sections.push(...parts.markers)
+  return sections.join('\n')
+}

package/src/compact/git.ts

@@ -0,0 +1,209 @@
+import { matchesCommandPatterns, normalizeCommandForDetection } from './detect.js'
+
+const GIT_COMMAND_PATTERNS = [/^git\s+(diff|status|log|show|stash)\b/] as const
+const RAW_GIT_DIFF_PATTERN = /^diff --git /m
+const RAW_GIT_STATUS_PATTERN = /^(?:## |(?:M|A|D|R|C|U|\?| )\S)/m
+
+/**
+ * One line of `git status --porcelain` output.
+ *
+ * Covers the v1 branch header (`## main...origin/main`), the v2 headers
+ * (`# branch.head main`), the `??` untracked form, and the two-column status
+ * form. The human report contains none of these shapes.
+ */
+const PORCELAIN_STATUS_LINE = /^(?:##?\s|\?\? .+|[ MADRCU?!]{2} .+)/
+
+/** Share of non-blank lines that must parse as porcelain before summarizing. */
+const PORCELAIN_LINE_MIN_RATIO = 0.8
+
+/**
+ * Whether a body is `git status --porcelain` rather than the human report.
+ *
+ * The two are indistinguishable line by line — ` M path` is valid porcelain
+ * and also occurs inside the human report — but only porcelain may be sliced
+ * with fixed column offsets. Running the summarizer over the human text
+ * silently invents and drops entries, so the body must be *consistently*
+ * porcelain before any of it is interpreted.
+ */
+function isPorcelainStatus(output: string): boolean {
+  const lines = output.split('\n').filter((line) => line.trim().length > 0)
+  if (lines.length === 0) return false
+  const matches = lines.filter((line) => PORCELAIN_STATUS_LINE.test(line)).length
+  return matches / lines.length >= PORCELAIN_LINE_MIN_RATIO
+}
+
+/** Whether the command is one of the git commands this module understands. */
+export function isGitCommand(command: string | undefined | null): boolean {
+  return matchesCommandPatterns(command, GIT_COMMAND_PATTERNS)
+}
+
+/**
+ * Condense a unified diff to file headers, hunk headers, and a bounded sample
+ * of changed lines, with an added/removed count per file.
+ */
+export function compactDiff(output: string, maxLines = 50): string {
+  const lines = output.split('\n')
+  const result: string[] = []
+  let currentFile = ''
+  let added = 0
+  let removed = 0
+  let inHunk = false
+  let hunkLines = 0
+  const maxHunkLines = 10
+
+  for (const line of lines) {
+    if (result.length >= maxLines) {
+      result.push('\n... (more changes truncated)')
+      break
+    }
+
+    if (line.startsWith('diff --git')) {
+      if (currentFile && (added > 0 || removed > 0)) result.push(`  +${added} -${removed}`)
+      const match = line.match(/diff --git a\/(.+) b\/(.+)/)
+      currentFile = match?.[2] ?? 'unknown'
+      result.push(`\n> ${currentFile}`)
+      added = 0
+      removed = 0
+      inHunk = false
+      continue
+    }
+
+    if (line.startsWith('@@')) {
+      inHunk = true
+      hunkLines = 0
+      result.push(`  ${line.match(/@@ .+ @@/)?.[0] ?? '@@'}`)
+      continue
+    }
+
+    if (!inHunk) continue
+
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      added++
+      if (hunkLines < maxHunkLines) {
+        result.push(`  ${line}`)
+        hunkLines++
+      }
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      removed++
+      if (hunkLines < maxHunkLines) {
+        result.push(`  ${line}`)
+        hunkLines++
+      }
+    } else if (hunkLines < maxHunkLines && !line.startsWith('\\')) {
+      if (hunkLines > 0) {
+        result.push(`  ${line}`)
+        hunkLines++
+      }
+    }
+
+    if (hunkLines === maxHunkLines) {
+      result.push('  ... (truncated)')
+      hunkLines++
+    }
+  }
+
+  if (currentFile && (added > 0 || removed > 0)) result.push(`  +${added} -${removed}`)
+  return result.join('\n')
+}
+
+interface StatusStats {
+  staged: number
+  modified: number
+  untracked: number
+  conflicts: number
+  stagedFiles: string[]
+  modifiedFiles: string[]
+  untrackedFiles: string[]
+}
+
+/** Condense `git status` porcelain output into per-bucket counts and samples. */
+export function compactStatus(output: string): string {
+  const lines = output.split('\n')
+  if (lines.length === 0 || (lines.length === 1 && lines[0]?.trim() === '')) return 'Clean working tree'
+
+  const stats: StatusStats = {
+    staged: 0,
+    modified: 0,
+    untracked: 0,
+    conflicts: 0,
+    stagedFiles: [],
+    modifiedFiles: [],
+    untrackedFiles: [],
+  }
+  let branchName = ''
+
+  for (const line of lines) {
+    if (line.startsWith('##')) {
+      const match = line.match(/## (.+)/)
+      if (match?.[1]) branchName = match[1].split('...')[0] ?? match[1]
+      continue
+    }
+    if (line.length < 3) continue
+
+    const status = line.slice(0, 2)
+    const filename = line.slice(3)
+    const indexStatus = status[0]
+    const worktreeStatus = status[1]
+
+    if (indexStatus !== undefined && ['M', 'A', 'D', 'R', 'C'].includes(indexStatus)) {
+      stats.staged++
+      stats.stagedFiles.push(filename)
+    }
+    if (indexStatus === 'U') stats.conflicts++
+    if (worktreeStatus !== undefined && ['M', 'D'].includes(worktreeStatus)) {
+      stats.modified++
+      stats.modifiedFiles.push(filename)
+    }
+    if (status === '??') {
+      stats.untracked++
+      stats.untrackedFiles.push(filename)
+    }
+  }
+
+  let result = `Branch: ${branchName}\n`
+  const append = (label: string, count: number, files: string[], shown: number): void => {
+    if (count === 0) return
+    result += `${label}: ${count} files\n`
+    for (const file of files.slice(0, shown)) result += `  ${file}\n`
+    if (count > shown) result += `  ... +${count - shown} more\n`
+  }
+  append('Staged', stats.staged, stats.stagedFiles, 5)
+  append('Modified', stats.modified, stats.modifiedFiles, 5)
+  append('Untracked', stats.untracked, stats.untrackedFiles, 3)
+  if (stats.conflicts > 0) result += `Conflicts: ${stats.conflicts} files\n`
+
+  return result.trim()
+}
+
+/** Keep the first `limit` log lines, capping each line's width. */
+export function compactLog(output: string, limit = 20): string {
+  const lines = output.split('\n')
+  const result: string[] = []
+  for (const line of lines.slice(0, limit)) {
+    result.push(line.length > 80 ? `${line.slice(0, 77)}...` : line)
+  }
+  if (lines.length > limit) result.push(`... and ${lines.length - limit} more commits`)
+  return result.join('\n')
+}
+
+/**
+ * Compact a git command's output, or `null` when nothing applies.
+ *
+ * Each branch first checks that the output actually looks like raw git output.
+ * A command like `git diff --stat` inside a wrapper, or a script whose name
+ * merely starts with `git`, would otherwise be rewritten into a summary of
+ * text this module never parsed correctly.
+ */
+export function compactGitOutput(output: string, command: string | undefined | null): string | null {
+  if (!isGitCommand(command)) return null
+  const normalized = normalizeCommandForDetection(command)
+  if (!normalized) return null
+
+  if (normalized.startsWith('git diff')) return RAW_GIT_DIFF_PATTERN.test(output) ? compactDiff(output) : null
+  if (normalized.startsWith('git status')) {
+    if (!isPorcelainStatus(output)) return null
+    return RAW_GIT_STATUS_PATTERN.test(output) ? compactStatus(output) : null
+  }
+  if (normalized.startsWith('git log')) return compactLog(output)
+  return null
+}