@wingsbutterfly/dsh-rtk 0.1.0

package/src/compact/source.ts

@@ -0,0 +1,244 @@
+import type { SourceCodeFilteringLevel } from '../config.js'
+
+/** A language whose comment syntax this module knows. */
+export type Language = 'javascript' | 'python' | 'rust' | 'go' | 'java' | 'c' | 'shell' | 'ruby' | 'unknown'
+
+const LANGUAGE_EXTENSIONS: Record<string, Language> = {
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.mjs': 'javascript',
+  '.cjs': 'javascript',
+  '.ts': 'javascript',
+  '.tsx': 'javascript',
+  '.mts': 'javascript',
+  '.cts': 'javascript',
+  '.py': 'python',
+  '.pyi': 'python',
+  '.rs': 'rust',
+  '.go': 'go',
+  '.java': 'java',
+  '.kt': 'java',
+  '.c': 'c',
+  '.h': 'c',
+  '.cc': 'c',
+  '.cpp': 'c',
+  '.hpp': 'c',
+  '.sh': 'shell',
+  '.bash': 'shell',
+  '.zsh': 'shell',
+  '.rb': 'ruby',
+}
+
+const LINE_COMMENT: Record<Language, string | undefined> = {
+  javascript: '//',
+  python: '#',
+  rust: '//',
+  go: '//',
+  java: '//',
+  c: '//',
+  shell: '#',
+  ruby: '#',
+  unknown: undefined,
+}
+
+const BLOCK_COMMENT: Partial<Record<Language, readonly [string, string]>> = {
+  javascript: ['/*', '*/'],
+  rust: ['/*', '*/'],
+  go: ['/*', '*/'],
+  java: ['/*', '*/'],
+  c: ['/*', '*/'],
+}
+
+/** Signature/declaration lines worth keeping when lines must be dropped. */
+const SIGNATURE_PATTERN = /^(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|enum|struct|impl|trait|def|fn|const|let|var|public|private|protected|static|pub|package|import|from|use|mod)\b/
+const IMPORT_PATTERN = /^(?:import|from|use|require|#include|package|mod)\b/
+
+/** Infer a source language from a file extension. */
+export function detectLanguage(filePath: string): Language {
+  const lastDot = filePath.lastIndexOf('.')
+  if (lastDot === -1) return 'unknown'
+  return LANGUAGE_EXTENSIONS[filePath.slice(lastDot).toLowerCase()] ?? 'unknown'
+}
+
+/**
+ * Keep the most informative `maxLines` lines of a source read.
+ *
+ * The first half of the budget is kept verbatim, after which only structural
+ * lines survive — signatures, imports, and lone braces — with a marker where
+ * body lines were dropped. This preserves the shape of the file (what is
+ * defined where) rather than an arbitrary prefix, which is what makes the
+ * result still usable for orientation.
+ *
+ * @param content - file text.
+ * @param maxLines - line budget.
+ * @returns the reduced text.
+ */
+export function smartTruncate(content: string, maxLines: number): string {
+  const lines = content.split('\n')
+  if (lines.length <= maxLines) return content
+
+  const result: string[] = []
+  let keptLines = 0
+  let skippedSection = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    const isImportant =
+      SIGNATURE_PATTERN.test(trimmed) ||
+      IMPORT_PATTERN.test(trimmed) ||
+      trimmed.startsWith('pub ') ||
+      trimmed.startsWith('export ') ||
+      trimmed === '}' ||
+      trimmed === '{'
+
+    if (isImportant || keptLines < maxLines / 2) {
+      if (skippedSection) {
+        result.push(`    // ... ${lines.length - keptLines} lines omitted`)
+        skippedSection = false
+      }
+      result.push(line)
+      keptLines += 1
+    } else {
+      skippedSection = true
+    }
+
+    if (keptLines >= maxLines - 1) break
+  }
+
+  if (skippedSection || keptLines < lines.length) {
+    result.push(`// ... ${lines.length - keptLines} more lines (total: ${lines.length})`)
+  }
+
+  return result.join('\n')
+}
+
+/**
+ * Remove non-documentation comments and collapse blank runs.
+ *
+ * Documentation comments — line docs and block docs alike — are kept: they
+ * carry the contract, which is the part a reader most often needs. A line
+ * whose comment marker appears inside a string literal is left alone, which is
+ * why the check is prefix-anchored rather than a plain substring search.
+ */
+function filterMinimal(content: string, language: Language): string {
+  const lineComment = LINE_COMMENT[language]
+  const block = BLOCK_COMMENT[language]
+  const lines = content.split('\n')
+  const result: string[] = []
+  let inBlockComment = false
+  let inDocstring = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    if (inBlockComment) {
+      if (block !== undefined && trimmed.includes(block[1])) inBlockComment = false
+      continue
+    }
+    if (inDocstring) {
+      result.push(line)
+      if (trimmed.endsWith('"""') || trimmed.endsWith("'''")) inDocstring = false
+      continue
+    }
+
+    if (language === 'python' && (trimmed.startsWith('"""') || trimmed.startsWith("'''"))) {
+      result.push(line)
+      const isSingleLine = trimmed.length > 3 && (trimmed.endsWith('"""') || trimmed.endsWith("'''"))
+      if (!isSingleLine) inDocstring = true
+      continue
+    }
+
+    if (block !== undefined && trimmed.startsWith(block[0]) && !trimmed.includes(block[1], block[0].length)) {
+      // A doc block (an extra `*` after the opener) is kept verbatim; any other
+      // block comment opens and hides the lines that follow it.
+      const afterOpener = trimmed.charAt(block[0].length)
+      if (afterOpener === '*') {
+        result.push(line)
+      } else {
+        inBlockComment = true
+      }
+      continue
+    }
+
+    if (lineComment !== undefined && trimmed.startsWith(lineComment)) {
+      // Doc comments stay; ordinary comments go. A doc marker is the comment
+      // prefix followed by `/` (`///`) or `!` (`//!`).
+      const afterMarker = trimmed.charAt(lineComment.length)
+      if (afterMarker === '/' || afterMarker === '!') result.push(line)
+      continue
+    }
+
+    result.push(line)
+  }
+
+  const collapsed: string[] = []
+  let blankRun = 0
+  for (const line of result) {
+    if (line.trim() === '') {
+      blankRun++
+      if (blankRun > 1) continue
+    } else {
+      blankRun = 0
+    }
+    collapsed.push(line)
+  }
+
+  return collapsed.join('\n')
+}
+
+/**
+ * Keep imports, constants, and signatures while replacing bodies with a marker.
+ *
+ * Deliberately the most lossy level: it answers "what is in this file" without
+ * pretending to answer "how does it work".
+ */
+function filterAggressive(content: string, language: Language): string {
+  const lines = content.split('\n')
+  const result: string[] = []
+  let bodyDepth = 0
+  let skipped = 0
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    const isStructural =
+      IMPORT_PATTERN.test(trimmed) ||
+      SIGNATURE_PATTERN.test(trimmed) ||
+      /^[A-Z_][A-Z0-9_]*\s*=/.test(trimmed) ||
+      trimmed === '}' ||
+      trimmed === '{' ||
+      trimmed === ''
+
+    if (isStructural) {
+      if (skipped > 0) {
+        result.push(`    // ... ${skipped} implementation lines omitted`)
+        skipped = 0
+      }
+      result.push(line)
+      bodyDepth = trimmed.endsWith('{') || trimmed.endsWith(':') ? bodyDepth + 1 : Math.max(0, bodyDepth - 1)
+      continue
+    }
+
+    if (bodyDepth > 0) {
+      skipped++
+      continue
+    }
+    result.push(line)
+  }
+
+  if (skipped > 0) result.push(`    // ... ${skipped} implementation lines omitted`)
+  return result.join('\n')
+}
+
+/** Apply the configured source-filtering level. */
+export function filterSourceCode(content: string, language: Language, level: SourceCodeFilteringLevel): string {
+  switch (level) {
+    case 'none':
+      return content
+    case 'minimal':
+      return filterMinimal(content, language)
+    case 'aggressive':
+      return filterAggressive(content, language)
+    default:
+      return content
+  }
+}

package/src/compact/test-output.ts

@@ -0,0 +1,184 @@
+import { matchesCommandPatterns } from './detect.js'
+
+interface TestSummary {
+  passed: number
+  failed: number
+  skipped: number
+  failures: string[]
+}
+
+const TEST_COMMAND_PATTERNS = [
+  /^npm\s+test\b/,
+  /^pnpm\s+test\b/,
+  /^yarn\s+test\b/,
+  /^bun\s+test\b/,
+  /^cargo\s+test\b/,
+  /^go\s+test\b/,
+  /^pytest\b/,
+  /^python\s+-m\s+pytest\b/,
+  /^(?:pnpm\s+)?(?:npx\s+)?vitest\b/,
+  /^(?:npx\s+)?jest\b/,
+  /^mocha\b/,
+  /^ava\b/,
+  /^tap\b/,
+  /^node\s+--test\b/,
+] as const
+
+const TEST_RESULT_PATTERNS = [
+  /test result:\s*(\w+)\.\s*(\d+)\s*passed;\s*(\d+)\s*failed;/,
+  /#\s*tests\s+(\d+)\s*$/m,
+  /(\d+)\s*passed(?:,\s*(\d+)\s*failed)?(?:,\s*(\d+)\s*skipped)?/i,
+  /(\d+)\s*pass(?:,\s*(\d+)\s*fail)?(?:,\s*(\d+)\s*skip)?/i,
+  /tests?:\s*(\d+)\s*passed(?:,\s*(\d+)\s*failed)?(?:,\s*(\d+)\s*skipped)?/i,
+]
+
+const FAILURE_START_PATTERNS = [
+  /^FAIL\s+/,
+  /^FAILED\s+/,
+  /^\s*●\s+/,
+  // U+2715 and U+2716 look alike and are both in the wild; `node --test` uses
+  // the heavy form, which a pattern written for the light one silently misses.
+  /^\s*[✕✖]\s+/,
+  /^\s*not ok\s+/,
+  /test\s+\w+\s+\.\.\.\s*FAILED/,
+  /thread\s+'\w+'\s+panicked/,
+]
+
+const FALLBACK_PASS_PATTERN = /(?:\b(?:ok|PASS)\b|[✓✔])/
+const FALLBACK_FAIL_PATTERN = /(?:\b(?:FAIL|fail)\b|[✗✕✖])/
+
+const MAX_FAILURES = 5
+const MAX_FAILURE_LINES = 4
+const BLANKS_TO_CLOSE_BLOCK = 2
+
+/**
+ * Read `node --test`'s tallies, which it prints on separate lines:
+ * `ℹ tests 2` / `ℹ pass 1` / `ℹ fail 1`.
+ *
+ * These are authoritative — the runner counted them — so they are preferred
+ * over every scraped-marker fallback.
+ */
+function extractNodeTestStats(output: string): Partial<TestSummary> | undefined {
+  const passed = output.match(/^\u2139\s*pass\s+(\d+)/m)
+  if (passed === null) return undefined
+  return {
+    passed: Number.parseInt(passed[1] ?? '0', 10) || 0,
+    failed: Number.parseInt(output.match(/^\u2139\s*fail\s+(\d+)/m)?.[1] ?? '0', 10) || 0,
+    skipped: Number.parseInt(output.match(/^\u2139\s*skipped\s+(\d+)/m)?.[1] ?? '0', 10) || 0,
+  }
+}
+
+function extractTestStats(output: string): Partial<TestSummary> {
+  const fromNodeTest = extractNodeTestStats(output)
+  if (fromNodeTest !== undefined) return fromNodeTest
+
+  for (const pattern of TEST_RESULT_PATTERNS) {
+    const match = output.match(pattern)
+    if (!match) continue
+    return {
+      passed: Number.parseInt(match[1] ?? '0', 10) || 0,
+      failed: Number.parseInt(match[2] ?? '0', 10) || 0,
+      skipped: Number.parseInt(match[3] ?? '0', 10) || 0,
+    }
+  }
+  return {}
+}
+
+/** Whether the command is a test runner this module understands. */
+export function isTestCommand(command: string | undefined | null): boolean {
+  return matchesCommandPatterns(command, TEST_COMMAND_PATTERNS)
+}
+
+/**
+ * Collapse test-runner output to a pass/fail/skip summary plus the first few
+ * failure excerpts.
+ *
+ * When no runner summary line can be parsed, per-line pass/fail markers are
+ * counted instead, so an unusual runner still yields a usable shape rather than
+ * a bare "0 passed".
+ */
+export function aggregateTestOutput(output: string, command: string | undefined | null): string | null {
+  if (!isTestCommand(command)) return null
+
+  const lines = output.split('\n')
+  const summary: TestSummary = { passed: 0, failed: 0, skipped: 0, failures: [] }
+
+  const stats = extractTestStats(output)
+  summary.passed = stats.passed ?? 0
+  summary.failed = stats.failed ?? 0
+  summary.skipped = stats.skipped ?? 0
+
+  if (summary.passed === 0 && summary.failed === 0) {
+    for (const line of lines) {
+      if (FALLBACK_PASS_PATTERN.test(line)) summary.passed++
+      if (FALLBACK_FAIL_PATTERN.test(line)) summary.failed++
+    }
+  }
+
+  if (summary.failed > 0) {
+    let inFailure = false
+    let currentFailure: string[] = []
+    let blankCount = 0
+
+    for (const line of lines) {
+      if (FAILURE_START_PATTERNS.some((pattern) => pattern.test(line))) {
+        if (inFailure && currentFailure.length > 0) summary.failures.push(currentFailure.join('\n'))
+        inFailure = true
+        currentFailure = [line]
+        blankCount = 0
+        continue
+      }
+
+      if (!inFailure) continue
+
+      if (line.trim() === '') {
+        blankCount++
+        if (blankCount >= BLANKS_TO_CLOSE_BLOCK && currentFailure.length > 3) {
+          summary.failures.push(currentFailure.join('\n'))
+          inFailure = false
+          currentFailure = []
+        } else {
+          currentFailure.push(line)
+        }
+        continue
+      }
+
+      if (line.match(/^\s/) || line.match(/^-/)) {
+        currentFailure.push(line)
+        blankCount = 0
+        continue
+      }
+
+      summary.failures.push(currentFailure.join('\n'))
+      inFailure = false
+      currentFailure = []
+    }
+
+    if (inFailure && currentFailure.length > 0) summary.failures.push(currentFailure.join('\n'))
+  }
+
+  const result: string[] = ['Test Results:']
+  result.push(`   PASS: ${summary.passed} passed`)
+  if (summary.failed > 0) result.push(`   FAIL: ${summary.failed} failed`)
+  if (summary.skipped > 0) result.push(`   SKIP: ${summary.skipped} skipped`)
+
+  if (summary.failed > 0 && summary.failures.length > 0) {
+    result.push('\n   Failures:')
+    for (const failure of summary.failures.slice(0, MAX_FAILURES)) {
+      const failureLines = failure.split('\n')
+      const firstLine = failureLines[0] ?? ''
+      result.push(`   - ${firstLine.slice(0, 70)}${firstLine.length > 70 ? '...' : ''}`)
+      for (const detailLine of failureLines.slice(1, MAX_FAILURE_LINES)) {
+        if (detailLine.trim()) result.push(`     ${detailLine.slice(0, 65)}${detailLine.length > 65 ? '...' : ''}`)
+      }
+      if (failureLines.length > MAX_FAILURE_LINES) {
+        result.push(`     ... (${failureLines.length - MAX_FAILURE_LINES} more lines)`)
+      }
+    }
+    if (summary.failures.length > MAX_FAILURES) {
+      result.push(`   ... and ${summary.failures.length - MAX_FAILURES} more failures`)
+    }
+  }
+
+  return result.join('\n')
+}

package/src/compact/text.ts

@@ -0,0 +1,86 @@
+/** Text primitives shared by every compaction technique. */
+
+const ANSI_CSI = /\u001b\[[0-9;]*[a-zA-Z]/g
+const ANSI_OSC_BEL = /\u001b\][0-9;]*(?:\u0007|\u001b\\)/g
+const ANSI_OSC_ST = /\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g
+
+/**
+ * Remove terminal color and formatting sequences.
+ *
+ * Covered: CSI (`ESC [ … letter`) and OSC (`ESC ] … BEL|ST`). The cheap guard
+ * matters because this runs on every text result and most have no escape byte
+ * at all.
+ */
+export function stripAnsi(text: string): string {
+  if (!text.includes('\u001b')) return text
+  return text.replace(ANSI_CSI, '').replace(ANSI_OSC_BEL, '').replace(ANSI_OSC_ST, '')
+}
+
+/** Keep at most `maxLength` characters, marking elision with a trailing ellipsis. */
+export function truncate(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text
+  if (maxLength < 3) return '...'
+  return `${text.slice(0, maxLength - 3)}...`
+}
+
+/** Number of lines, counting a trailing newline as a terminator rather than a new line. */
+export function countLines(text: string): number {
+  if (!text) return 0
+  const normalized = text.endsWith('\n') ? text.slice(0, -1) : text
+  if (!normalized) return 1
+  return normalized.split('\n').length
+}
+
+function detectPathSeparator(path: string): '/' | '\\' {
+  return path.includes('\\') && !path.includes('/') ? '\\' : '/'
+}
+
+function detectPathPrefix(path: string, separator: '/' | '\\'): string {
+  if (/^[A-Za-z]:[\\/]/.test(path)) return `${path.slice(0, 2)}${separator}`
+  if (path.startsWith('\\\\') || path.startsWith('//')) {
+    const parts = path.split(/[\\/]+/).filter((part) => part.length > 0)
+    if (parts.length >= 2) return `${separator}${separator}${parts[0]}${separator}${parts[1]}${separator}`
+    return `${separator}${separator}`
+  }
+  if (path.startsWith('/') || path.startsWith('\\')) return separator
+  return ''
+}
+
+/**
+ * Shorten a path to `maxLength` by eliding its middle segments.
+ *
+ * The last segment survives because it is the part a reader needs; earlier
+ * candidates keep one parent directory when the budget allows, which is what
+ * disambiguates two files with the same basename.
+ */
+export function compactPath(path: string, maxLength: number): string {
+  if (path.length <= maxLength) return path
+  if (maxLength < 2) return path.slice(0, maxLength)
+
+  const separator = detectPathSeparator(path)
+  const prefix = detectPathPrefix(path, separator)
+  const segments = path
+    .slice(prefix.length)
+    .split(/[\\/]+/)
+    .filter((segment) => segment.length > 0)
+
+  const lastSegment = segments[segments.length - 1] ?? path.slice(-(maxLength - 1))
+  const previousSegment = segments[segments.length - 2]
+  const tail = [previousSegment, lastSegment].filter((segment): segment is string => segment !== undefined)
+  const join = (head: string, parts: string[]): string => {
+    const body = parts.join(separator)
+    return head ? `${head}${body}` : body
+  }
+
+  const candidates = [
+    join(prefix, ['…', ...tail]),
+    join('', ['…', ...tail]),
+    join('', ['…', lastSegment]),
+    `…${path.slice(-(maxLength - 1))}`,
+  ]
+
+  for (const candidate of candidates) {
+    if (candidate.length <= maxLength) return candidate
+  }
+  return `…${lastSegment.slice(-(maxLength - 1))}`
+}