@tracehound/cli 1.2.0

package/src/index.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * Tracehound CLI - Evaluation Runtime
+ *
+ * Commands:
+ * - tracehound status     : Show current system status
+ * - tracehound stats      : Show threat statistics
+ * - tracehound inspect    : Inspect quarantine
+ * - tracehound watch      : Live TUI dashboard
+ */
+
+import { Command } from 'commander'
+import { inspectCommand } from './commands/inspect.js'
+import { statsCommand } from './commands/stats.js'
+import { statusCommand } from './commands/status.js'
+import { watchCommand } from './commands/watch.js'
+
+import { fileURLToPath } from 'url'
+
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+const { version } = require('../package.json')
+
+export const program = new Command()
+
+program.name('tracehound').description('Tracehound CLI - Runtime Security Buffer').version(version)
+
+// Register commands
+program.addCommand(statusCommand)
+program.addCommand(statsCommand)
+program.addCommand(inspectCommand)
+program.addCommand(watchCommand)
+
+// Only parse if executed directly
+const isMain =
+  process.argv[1] && fileURLToPath(import.meta.url).endsWith(process.argv[1].replace(/\\/g, '/'))
+
+if (isMain || process.env.NODE_ENV === 'cli-run') {
+  program.parse()
+}

package/src/lib/theme.ts

@@ -0,0 +1,117 @@
+/**
+ * ANSI Theme - Soft Dark Material
+ *
+ * Terminal color utilities with a beautiful dark theme
+ */
+
+// ANSI escape codes
+const ESC = '\x1b['
+const RESET = `${ESC}0m`
+
+// 256-color palette for soft dark material theme
+export const theme = {
+  // Base colors
+  bg: `${ESC}48;5;235m`, // Soft dark gray background
+  fg: `${ESC}38;5;253m`, // Light gray text
+
+  // Accent colors (Material Design inspired)
+  primary: `${ESC}38;5;75m`, // Soft blue
+  secondary: `${ESC}38;5;183m`, // Soft purple
+  accent: `${ESC}38;5;114m`, // Soft green
+
+  // Severity colors
+  critical: `${ESC}38;5;203m`, // Soft red
+  high: `${ESC}38;5;215m`, // Soft orange
+  medium: `${ESC}38;5;221m`, // Soft yellow
+  low: `${ESC}38;5;114m`, // Soft green
+
+  // UI elements
+  border: `${ESC}38;5;240m`, // Dim gray for borders
+  muted: `${ESC}38;5;245m`, // Muted text
+  success: `${ESC}38;5;114m`, // Green
+  warning: `${ESC}38;5;215m`, // Orange
+  error: `${ESC}38;5;203m`, // Red
+
+  // Styles
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  reset: RESET,
+}
+
+// Color helper functions
+export function colorize(text: string, ...styles: string[]): string {
+  return `${styles.join('')}${text}${RESET}`
+}
+
+export function primary(text: string): string {
+  return colorize(text, theme.primary)
+}
+
+export function secondary(text: string): string {
+  return colorize(text, theme.secondary)
+}
+
+export function accent(text: string): string {
+  return colorize(text, theme.accent)
+}
+
+export function muted(text: string): string {
+  return colorize(text, theme.muted)
+}
+
+export function bold(text: string): string {
+  return colorize(text, theme.bold)
+}
+
+export function success(text: string): string {
+  return colorize(text, theme.success)
+}
+
+export function warning(text: string): string {
+  return colorize(text, theme.warning)
+}
+
+export function error(text: string): string {
+  return colorize(text, theme.error)
+}
+
+export function severity(level: string): string {
+  switch (level) {
+    case 'critical':
+      return colorize(`● ${level}`, theme.critical)
+    case 'high':
+      return colorize(`● ${level}`, theme.high)
+    case 'medium':
+      return colorize(`● ${level}`, theme.medium)
+    case 'low':
+      return colorize(`● ${level}`, theme.low)
+    default:
+      return level
+  }
+}
+
+// Progress bar
+export function progressBar(current: number, max: number, width = 20): string {
+  const ratio = max > 0 ? current / max : 0
+  const filled = Math.round(ratio * width)
+  const empty = width - filled
+
+  const filledColor = ratio > 0.9 ? theme.critical : ratio > 0.7 ? theme.warning : theme.accent
+  const bar = `${filledColor}${'█'.repeat(filled)}${theme.muted}${'░'.repeat(empty)}${RESET}`
+
+  return bar
+}
+
+// Clear screen
+export function clearScreen(): void {
+  process.stdout.write('\x1b[2J\x1b[H')
+}
+
+// Hide/show cursor
+export function hideCursor(): void {
+  process.stdout.write('\x1b[?25l')
+}
+
+export function showCursor(): void {
+  process.stdout.write('\x1b[?25h')
+}

package/tests/commands.test.ts

@@ -0,0 +1,226 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { inspectCommand } from '../src/commands/inspect.js'
+import { statsCommand } from '../src/commands/stats.js'
+import { statusCommand } from '../src/commands/status.js'
+import { watchCommand } from '../src/commands/watch.js'
+
+describe('CLI Commands', () => {
+  describe('Smoke tests', () => {
+    it('should have inspect command', async () => {
+      const { inspectCommand } = await import('../src/commands/inspect.js')
+      expect(inspectCommand).toBeDefined()
+      expect(typeof inspectCommand).toBe('object')
+    })
+
+    it('should have stats command', async () => {
+      const { statsCommand } = await import('../src/commands/stats.js')
+      expect(statsCommand).toBeDefined()
+      expect(typeof statsCommand).toBe('object')
+    })
+
+    it('should have status command', async () => {
+      const { statusCommand } = await import('../src/commands/status.js')
+      expect(statusCommand).toBeDefined()
+      expect(typeof statusCommand).toBe('object')
+    })
+
+    it('should have watch command', async () => {
+      const { watchCommand } = await import('../src/commands/watch.js')
+      expect(watchCommand).toBeDefined()
+      expect(typeof watchCommand).toBe('object')
+    })
+  })
+
+  describe('Command structure', () => {
+    it('inspect command should be a Commander command', async () => {
+      const { inspectCommand } = await import('../src/commands/inspect.js')
+      expect(inspectCommand.name()).toBe('inspect')
+      expect(inspectCommand.description()).toBeTruthy()
+    })
+
+    it('stats command should be a Commander command', async () => {
+      const { statsCommand } = await import('../src/commands/stats.js')
+      expect(statsCommand.name()).toBe('stats')
+      expect(statsCommand.description()).toBeTruthy()
+    })
+
+    it('status command should be a Commander command', async () => {
+      const { statusCommand } = await import('../src/commands/status.js')
+      expect(statusCommand.name()).toBe('status')
+      expect(statusCommand.description()).toBeTruthy()
+    })
+
+    it('watch command should be a Commander command', () => {
+      expect(watchCommand.name()).toBe('watch')
+      expect(watchCommand.description()).toBeTruthy()
+    })
+  })
+
+  describe('Command execution', () => {
+    let logSpy: any
+
+    beforeEach(() => {
+      logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    })
+
+    afterEach(() => {
+      logSpy.mockRestore()
+      // Reset commander options to avoid state leakage
+      inspectCommand.setOptionValue('signature', undefined)
+      inspectCommand.setOptionValue('limit', '10')
+      inspectCommand.setOptionValue('json', undefined)
+      statusCommand.setOptionValue('json', undefined)
+      statsCommand.setOptionValue('json', undefined)
+      statsCommand.setOptionValue('since', '24h')
+    })
+
+    it('status command action should print status', () => {
+      statusCommand.exitOverride()
+      statusCommand.parse(['status'], { from: 'user' })
+
+      expect(logSpy).toHaveBeenCalled()
+      // Look for a known string in the output
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('TRACEHOUND STATUS')
+    })
+
+    it('status command action should print JSON', () => {
+      statusCommand.exitOverride()
+      statusCommand.parse(['status', '--json'], { from: 'user' })
+
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('"version": "1.2.0"')
+    })
+
+    it('stats command action should print stats', () => {
+      statsCommand.exitOverride()
+      statsCommand.parse(['stats'], { from: 'user' })
+
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('THREAT STATISTICS')
+    })
+
+    it('inspect command action should print empty quarantine message', () => {
+      inspectCommand.exitOverride()
+      inspectCommand.parse(['inspect', '--limit', '5'], { from: 'user' })
+
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('Quarantine is empty')
+    })
+
+    it('inspect command action should print not found message for signature', () => {
+      inspectCommand.exitOverride()
+      inspectCommand.parse(['inspect', '--signature', 'missing-sig'], { from: 'user' })
+
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('Evidence not found')
+    })
+
+    it('inspect command action should print JSON list', () => {
+      inspectCommand.exitOverride()
+      inspectCommand.parse(['inspect', '--json'], { from: 'user' })
+
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('[]')
+    })
+  })
+
+  describe('Theme Utilities', () => {
+    it('color functions should return ANSI strings', async () => {
+      const { primary, secondary, accent, muted, bold, success, warning, error } =
+        await import('../src/lib/theme.js')
+
+      expect(primary('test')).toContain('\x1b[38;5;75m')
+      expect(secondary('test')).toContain('\x1b[38;5;183m')
+      expect(accent('test')).toContain('\x1b[38;5;114m')
+      expect(muted('test')).toContain('\x1b[38;5;245m')
+      expect(bold('test')).toContain('\x1b[1m')
+      expect(success('test')).toContain('\x1b[38;5;114m')
+      expect(warning('test')).toContain('\x1b[38;5;215m')
+      expect(error('test')).toContain('\x1b[38;5;203m')
+    })
+
+    it('severity function should return colored labels', async () => {
+      const { severity } = await import('../src/lib/theme.js')
+
+      expect(severity('critical')).toContain('\x1b[38;5;203m')
+      expect(severity('high')).toContain('\x1b[38;5;215m')
+      expect(severity('medium')).toContain('\x1b[38;5;221m')
+      expect(severity('low')).toContain('\x1b[38;5;114m')
+      expect(severity('unknown')).toBe('unknown')
+    })
+
+    it('progressBar should handle different ratios', async () => {
+      const { progressBar } = await import('../src/lib/theme.js')
+
+      const p1 = progressBar(0, 100, 10)
+      expect(p1).toContain('░'.repeat(10))
+
+      const p2 = progressBar(50, 100, 10)
+      expect(p2).toContain('█'.repeat(5))
+      expect(p2).toContain('░'.repeat(5))
+
+      const p3 = progressBar(100, 100, 10)
+      expect(p3).toContain('█'.repeat(10))
+    })
+
+    it('cursor and screen utilities should call stdout.write', async () => {
+      const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true)
+      const { clearScreen, hideCursor, showCursor } = await import('../src/lib/theme.js')
+
+      clearScreen()
+      expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('\x1b[2J'))
+
+      hideCursor()
+      expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('\x1b[?25l'))
+
+      showCursor()
+      expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('\x1b[?25h'))
+
+      writeSpy.mockRestore()
+    })
+  })
+
+  describe('Watch command logic', () => {
+    let logSpy: any
+
+    beforeEach(() => {
+      logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    })
+
+    afterEach(() => {
+      logSpy.mockRestore()
+    })
+
+    it('should get system snapshot', async () => {
+      const { getSnapshot } = await import('../src/commands/watch.js')
+      const snapshot = getSnapshot()
+      expect(snapshot.system.version).toBe('1.2.0')
+      expect(snapshot.timestamp).toBeDefined()
+    })
+
+    it('should render dashboard without errors', async () => {
+      const { renderDashboard, getSnapshot } = await import('../src/commands/watch.js')
+      const snapshot = getSnapshot()
+
+      renderDashboard(snapshot, 1000)
+
+      const output = logSpy.mock.calls.map((call: any) => call[0]).join('\n')
+      expect(output).toContain('TRACEHOUND LIVE DASHBOARD')
+      expect(output).toContain('SYSTEM')
+    })
+
+    it('should handle dashboard options', () => {
+      expect(watchCommand.options.find((o) => o.short === '-r')).toBeDefined()
+    })
+  })
+
+  describe('CLI Entry Point', () => {
+    it('should have all commands registered', async () => {
+      const { program } = await import('../src/index.js')
+      expect(program.commands.map((c) => c.name())).toEqual(
+        expect.arrayContaining(['status', 'stats', 'inspect', 'watch']),
+      )
+    })
+  })
+})

package/tests/smoke.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest'
+import { statusCommand } from '../src/commands/status.js'
+import { statsCommand } from '../src/commands/stats.js'
+import { inspectCommand } from '../src/commands/inspect.js'
+import { watchCommand } from '../src/commands/watch.js'
+
+describe('CLI Smoke Tests', () => {
+  it('should export status command', () => {
+    expect(statusCommand.name()).toBe('status')
+    expect(statusCommand.description()).toContain('status')
+  })
+
+  it('should export stats command', () => {
+    expect(statsCommand.name()).toBe('stats')
+    expect(statsCommand.description()).toContain('statistics')
+  })
+
+  it('should export inspect command', () => {
+    expect(inspectCommand.name()).toBe('inspect')
+    expect(inspectCommand.description()).toContain('Inspect')
+  })
+
+  it('should export watch command', () => {
+    expect(watchCommand.name()).toBe('watch')
+    expect(watchCommand.description()).toContain('dashboard')
+  })
+})

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "tests"
+  ]
+}