@g3nomaly/g3n-mods 0.0.0-stage → 0.1.1

package/mods/hide-personal-data/hooks/register.tsx

@@ -0,0 +1,196 @@
+// packages/g3n-mods/mods/hide-personal-data/hooks/register.tsx
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register, RenderChildren } from 'claude-code'
+
+import type { PersonalKind, PersonalSpan } from '../types'
+
+const isOff = atom({ plugin: 'hide-personal-data', key: 'isOff' } as const, false)
+const knownNames = atom({ plugin: 'hide-personal-data', key: 'names' } as const, [])
+
+const MASK = '#3b4252'
+const REVEAL = '#4c566a'
+const ACCENT = '#e0775a'
+
+/** Patterns per kind, tried in this order; an earlier kind wins an overlap. */
+const PATTERNS: ReadonlyArray<[PersonalKind, RegExp]> = [
+  ['email', /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g],
+  ['iban', /\b[A-Z]{2}\d{2}(?: ?[A-Z0-9]{4}){3,7}(?: ?[A-Z0-9]{1,3})?\b/g],
+  ['card', /\b(?:\d{4}[ -]?){3}\d{1,4}\b/g],
+  ['phone', /(?<![\w.])\+?\d[\d ().-]{7,}\d(?![\w.])/g],
+]
+
+/** Common first names; one followed by a capitalised word reads as a full name. */
+const FIRST_NAMES = new Set(`
+  aaron adam ahmed aisha alex alexander alice amanda amir amy ana andrea andrew angela anna anne anthony arjun ben benjamin
+  bob brian carlos carmen carol catherine charles chen chloe chris christina christopher daniel david deepak diana diego
+  dmitri elena elizabeth emily emma eric erik eva fatima felix fernando francesca frank gabriel george grace hannah hans
+  harry helen henry hiroshi ian isabel isabella jack jacob james jan jane jason javier jennifer jessica john jonathan jose
+  joseph juan julia julian karen kate katherine kevin kim laura lars lauren laura leo li lin linda lisa lucas lucia luis
+  maria mark marta martin mary matteo matthew max mei michael michelle miguel mohammed nadia natalia nicholas nina noah
+  oliver olivia omar pablo paul peter pieter priya rachel rahul raj rebecca richard robert ryan sam samuel sara sarah
+  sebastian sophia sophie stefan steven susan thomas tim tom tomas valentina victor wei william yuki yusuf zoe
+`.split(/\s+/).filter(name => name.length > 0))
+
+const FULL_NAME = /\b([A-Z][a-z]+) ((?:van |de |von |da )?[A-Z][a-z]+(?:[-'][A-Z][a-z]+)?)\b/g
+const TITLED_NAME = /\b(?:Mr|Mrs|Ms|Dr|Prof)\.? [A-Z][a-z]+(?:[-'][A-Z][a-z]+)?\b/g
+
+/**
+ * Counts the digits in a text.
+ *
+ * @param text - Text to count in, e.g. a phone number.
+ * @returns Number of digit characters.
+ */
+function digitCount(text: string): number {
+  return text.replace(/\D/g, '').length
+}
+
+/**
+ * Escapes the characters that have a meaning in a regular expression.
+ *
+ * @param text - Literal text to match exactly.
+ * @returns The text with each special character escaped.
+ */
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * @brief Finds personal data in a text: emails, phone numbers, IBANs, card numbers and names.
+ *
+ * Names come from `names` and from common first names followed by a surname.
+ * Overlapping matches keep the earlier, longer one.
+ *
+ * @param text - Text to search, a line or a whole message.
+ * @param names - Exact names to mask wherever they occur, e.g. `["Ada Lovelace"]`.
+ * @returns The matches in text order.
+ */
+export function findPersonalData(text: string, names: readonly string[]): PersonalSpan[] {
+  const spans: PersonalSpan[] = []
+  for (const [kind, pattern] of PATTERNS) {
+    for (const match of text.matchAll(pattern)) {
+      if (kind === 'phone' && digitCount(match[0]) < 9) continue
+      spans.push({ kind, start: match.index, end: match.index + match[0].length })
+    }
+  }
+  for (const name of names) {
+    if (name.trim().length < 3) continue
+    for (const match of text.matchAll(new RegExp(`\\b${escapeRegExp(name.trim())}\\b`, 'g'))) {
+      spans.push({ kind: 'name', start: match.index, end: match.index + match[0].length })
+    }
+  }
+  for (const match of text.matchAll(FULL_NAME)) {
+    if (FIRST_NAMES.has((match[1] ?? '').toLowerCase())) spans.push({ kind: 'name', start: match.index, end: match.index + match[0].length })
+  }
+  for (const match of text.matchAll(TITLED_NAME)) {
+    spans.push({ kind: 'name', start: match.index, end: match.index + match[0].length })
+  }
+
+  const sorted = spans.sort((a, b) => a.start - b.start || b.end - a.end)
+  const kept: PersonalSpan[] = []
+  for (const span of sorted) {
+    const last = kept[kept.length - 1]
+    if (last === undefined || span.start >= last.end) kept.push(span)
+  }
+  return kept
+}
+
+/**
+ * Strips the Markdown a plain-text line would show raw: heading hashes, bold, underscore and code marks.
+ *
+ * @param line - One line of a message.
+ * @returns The line without those marks.
+ */
+function plain(line: string): string {
+  return line.replace(/^#{1,6}\s+/, '').replace(/(\*\*|__|`)/g, '')
+}
+
+/**
+ * Reads the git user's name and email from the repository config, the names most likely to show up in replies.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @returns The values that are set, `user.name` first, or `[]` when neither is set.
+ */
+async function gitIdentity($: EngineInterface): Promise<string[]> {
+  const found: string[] = []
+  for (const key of ['user.name', 'user.email']) {
+    const run = await $.process.run(['git', 'config', '--get', key]).catch(() => undefined)
+    const value = run?.exitCode === 0 ? run.stdout.trim() : ''
+    if (value.length > 0) found.push(value)
+  }
+  return found
+}
+
+/**
+ * Registers this mod's `hide-personal-data` command, its session hook, and its assistant message hook.
+ *
+ * @param on - Hook registration function the engine passes in.
+ * @param options - Plugin options; `names` is a comma-separated list of names to always mask.
+ */
+export const register: Register = (on, options) => {
+  const configured = typeof options.names === 'string'
+    ? options.names.split(',').map(name => name.trim()).filter(name => name.length > 0)
+    : []
+
+  on('session.start', async ($, e, next) => {
+    await $.command.register({
+      name: 'hide-personal-data',
+      description: 'Turn masking of names, emails and other personal data on or off',
+      argumentHint: 'on | off',
+    })
+    const identity = await gitIdentity($)
+    await update($, knownNames, () => [...configured, ...identity])
+    return next(e)
+  })
+
+  on('command.run', { command: 'hide-personal-data' }, async ($, e) => {
+    const wanted = e.args.trim()
+    if (wanted === 'on' || wanted === 'off') await update($, isOff, () => wanted === 'off')
+    const off = await read($, isOff)
+    return { text: `Personal data is ${off ? 'shown as written' : 'masked; hover a mask to read it'}.` }
+  })
+
+  on('ui.render', { component: 'AssistantMessage' }, async ($, e, next) => {
+    if (await read($, isOff)) return next(e)
+    const text = e.props.text
+    const names = await read($, knownNames)
+    if (findPersonalData(text, names).length === 0) return next(e)
+
+    const { Box, Text, Markdown } = $.ui.resolve(e)
+    const blocks: RenderChildren[] = []
+    let prose: string[] = []
+    /**
+     * Emits the prose lines collected so far as one Markdown block, then clears them.
+     */
+    const flush = () => {
+      if (prose.length > 0) blocks.push(<Markdown text={prose.join('\n')} />)
+      prose = []
+    }
+
+    text.split('\n').forEach((line, lineIndex) => {
+      const spans = findPersonalData(line, names)
+      if (spans.length === 0) {
+        prose.push(line)
+        return
+      }
+      flush()
+      const parts: RenderChildren[] = []
+      let at = 0
+      spans.forEach((span, spanIndex) => {
+        if (span.start > at) parts.push(<Text>{plain(line.slice(at, span.start))}</Text>)
+        const scope = `pd-${e.requestId}-${lineIndex}-${spanIndex}`
+        parts.push(<Text color={ACCENT}>▎</Text>)
+        parts.push(
+          <Text color={MASK} backgroundColor={MASK} hover={{ scope, color: 'text', backgroundColor: REVEAL }}>
+            {line.slice(span.start, span.end)}
+          </Text>,
+        )
+        at = span.end
+      })
+      if (at < line.length) parts.push(<Text>{plain(line.slice(at))}</Text>)
+      blocks.push(<Box flexDirection="row" flexWrap="wrap">{parts}</Box>)
+    })
+    flush()
+
+    return <Box flexDirection="column">{blocks}</Box>
+  })
+}

package/mods/hide-personal-data/types/index.d.ts

@@ -0,0 +1,17 @@
+// packages/g3n-mods/mods/hide-personal-data/types/index.d.ts
+
+/** What kind of personal data a match is. */
+export type PersonalKind = 'email' | 'phone' | 'iban' | 'card' | 'name'
+
+/** One match in a text: its kind and its character range, `end` exclusive. */
+export type PersonalSpan = {
+  kind: PersonalKind
+  start: number
+  end: number
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    'hide-personal-data': { isOff: boolean; names: string[] }
+  }
+}

package/mods/mini-game/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "mini-game",
+  "version": "0.1.0",
+  "description": "Minesweeper to play while Claude works.",
+  "author": {
+    "name": "g3ntrovert"
+  },
+  "types": "./types/index.d.ts"
+}

package/mods/mini-game/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

package/mods/mini-game/hooks/register.tsx

@@ -0,0 +1,273 @@
+// packages/g3n-mods/mods/mini-game/hooks/register.tsx
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register } from 'claude-code'
+
+import type { Game } from '../types'
+
+const PANE = 'mini-game'
+const TITLE = 'Minesweeper'
+const game = atom({ plugin: 'mini-game', key: 'game' } as const, null)
+const best = atom({ plugin: 'mini-game', key: 'best' } as const, null)
+
+const SIZE = 9
+const MINES = 10
+const BEST_KEY = 'best-seconds'
+/** How long a turn runs before the mod suggests a game, once per session. */
+const HINT_AFTER_MS = 60_000
+const NUMBER_COLORS = [undefined, '#6b8fd6', '#7cc47f', '#e06c6c', '#9b87f5', '#e0775a', '#5fb3c4', '#d0d0d0', '#8a8f98']
+
+/**
+ * Lists the cells around `cell` on a `size` × `size` board.
+ *
+ * @param cell - Cell number, counted row by row from `0`.
+ * @param size - Board width and height in cells.
+ * @returns The neighboring cell numbers, from one to eight of them.
+ */
+export function neighbors(cell: number, size: number): number[] {
+  const row = Math.floor(cell / size)
+  const col = cell % size
+  const found: number[] = []
+  for (let dr = -1; dr <= 1; dr++) {
+    for (let dc = -1; dc <= 1; dc++) {
+      const r = row + dr
+      const c = col + dc
+      if ((dr !== 0 || dc !== 0) && r >= 0 && r < size && c >= 0 && c < size) found.push(r * size + c)
+    }
+  }
+  return found
+}
+
+/**
+ * Counts the mines in the cells around `cell`.
+ *
+ * @param board - Board to read, see `Game`.
+ * @param cell - Cell number to count around.
+ * @returns Number of neighboring mines, from `0` to `8`.
+ */
+function adjacentMines(board: Game, cell: number): number {
+  return neighbors(cell, board.size).filter(n => board.mines.includes(n)).length
+}
+
+/**
+ * Picks random cells for the mines, leaving `safe` and the cells around it free.
+ *
+ * @param board - Board to place mines on, see `Game`.
+ * @param safe - Cell the first reveal hit, which must not be a mine.
+ * @returns Mine cell numbers, `board.mineCount` of them.
+ */
+function placeMines(board: Game, safe: number): number[] {
+  const banned = new Set([safe, ...neighbors(safe, board.size)])
+  const free = Array.from({ length: board.size * board.size }, (_, i) => i).filter(i => !banned.has(i))
+  for (let i = free.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1))
+    ;[free[i], free[j]] = [free[j] ?? 0, free[i] ?? 0]
+  }
+  return free.slice(0, board.mineCount)
+}
+
+/**
+ * @brief Reveals one cell: the first reveal places the mines, a zero opens its
+ * neighbours, a mine ends the game, and the last safe cell wins it.
+ *
+ * @param board - Board to reveal on, see `Game`.
+ * @param cell - Cell number to reveal.
+ * @param now - Milliseconds since the epoch, stamped as the start or end time.
+ * @returns The board after the reveal, or the same board when the cell cannot be revealed.
+ */
+export function reveal(board: Game, cell: number, now: number): Game {
+  if (board.status === 'won' || board.status === 'lost') return board
+  if (board.revealed.includes(cell) || board.flagged.includes(cell)) return board
+
+  const mines = board.status === 'ready' ? placeMines(board, cell) : board.mines
+  const started: Game = board.status === 'ready' ? { ...board, mines, status: 'playing', startedAt: now } : board
+  if (mines.includes(cell)) return { ...started, revealed: [...started.revealed, cell], status: 'lost', endedAt: now }
+
+  const open = new Set(started.revealed)
+  const queue = [cell]
+  while (queue.length > 0) {
+    const next = queue.pop() ?? cell
+    if (open.has(next) || started.flagged.includes(next)) continue
+    open.add(next)
+    if (adjacentMines(started, next) === 0) queue.push(...neighbors(next, started.size).filter(n => !open.has(n)))
+  }
+
+  const revealed = [...open]
+  const isWon = revealed.length === started.size * started.size - started.mineCount
+  return isWon ? { ...started, revealed, status: 'won', endedAt: now } : { ...started, revealed }
+}
+
+/**
+ * Creates a board in the `ready` state, with no mines placed yet.
+ *
+ * @param now - Milliseconds since the epoch, stamped as the start time.
+ * @returns The new board, see `Game`.
+ */
+function newGame(now: number): Game {
+  return { size: SIZE, mineCount: MINES, mines: [], revealed: [], flagged: [], status: 'ready', isFlagMode: false, startedAt: now }
+}
+
+/**
+ * Starts a new board and shows the pane.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ */
+async function startGame($: EngineInterface): Promise<void> {
+  const now = await $.clock.now()
+  await update($, game, () => newGame(now))
+  await $.ui.open({ id: PANE, title: TITLE })
+}
+
+/**
+ * Reveals or flags a cell, as the flag mode says, and records a best time on a win.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @param cell - Cell number the player pressed.
+ */
+async function pressCell($: EngineInterface, cell: number): Promise<void> {
+  const now = await $.clock.now()
+  const after = await update($, game, board => {
+    if (board === null) return board
+    if (!board.isFlagMode) return reveal(board, cell, now)
+    if (board.revealed.includes(cell) || board.status === 'won' || board.status === 'lost') return board
+    const flagged = board.flagged.includes(cell) ? board.flagged.filter(c => c !== cell) : [...board.flagged, cell]
+    return { ...board, flagged }
+  })
+  if (after?.status === 'won' && after.endedAt === now) {
+    const seconds = Math.round((now - after.startedAt) / 1000)
+    const previous = await read($, best)
+    if (previous === null || seconds < previous) {
+      await update($, best, () => seconds)
+      await $.store.set(BEST_KEY, seconds)
+    }
+    $.ui.toast(`Cleared in ${seconds}s${previous === null || seconds < previous ? ', a new best' : ''}`)
+  }
+}
+
+/**
+ * Switches the board between revealing and flagging cells.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ */
+async function toggleFlagMode($: EngineInterface): Promise<void> {
+  await update($, game, board => (board === null ? board : { ...board, isFlagMode: !board.isFlagMode }))
+}
+
+/**
+ * Redraws the timer once a second while a game is on.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ */
+async function tick($: EngineInterface): Promise<void> {
+  if ((await read($, game))?.status === 'playing') $.ui.invalidate('ui.render')
+}
+
+let hintTurn: string | undefined
+let isHinted = false
+
+/**
+ * Suggests a game once per session, when a turn is still running after a minute.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @param turnId - Turn the hint was scheduled for; the hint is skipped when another turn is running.
+ */
+async function hint($: EngineInterface, turnId: string): Promise<void> {
+  if (isHinted || hintTurn !== turnId) return
+  if ((await $.ui.panes()).some(pane => pane.id === PANE)) return
+  isHinted = true
+  $.ui.toast('Waiting on Claude? /mini-game opens Minesweeper.')
+}
+
+/**
+ * Registers this mod's `mini-game` command, its session, turn and pane hooks.
+ *
+ * @param on - Hook registration function the engine passes in.
+ */
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    await $.command.register({ name: 'mini-game', description: 'Play Minesweeper while Claude works' })
+    const stored = await $.store.get(BEST_KEY)
+    if (typeof stored === 'number') await update($, best, () => stored)
+    $.clock.every(1000, () => void tick($))
+    return next(e)
+  })
+
+  on('command.run', { command: 'mini-game' }, async $ => {
+    const current = await read($, game)
+    if (current === null || current.status === 'won' || current.status === 'lost') await startGame($)
+    else await $.ui.open({ id: PANE, title: TITLE })
+    return { text: 'Minesweeper is open. Clear the board without hitting a mine.' }
+  })
+
+  on('turn.start', async ($, e, next) => {
+    hintTurn = e.turnId
+    const turnId = e.turnId
+    $.clock.after(HINT_AFTER_MS, () => void hint($, turnId))
+    return next(e)
+  })
+
+  on('turn.complete', async ($, e, next) => {
+    if (e.agentId === undefined) hintTurn = undefined
+    return next(e)
+  })
+
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const { Box, Text, Button } = $.ui.resolve(e)
+    const board = await read($, game)
+    if (board === null) {
+      return <Button key="new" label="new game" variant="primary" onPress={() => startGame($)} />
+    }
+
+    const now = await $.clock.now()
+    const elapsed = board.status === 'ready' ? 0 : Math.round(((board.endedAt ?? now) - board.startedAt) / 1000)
+    const record = await read($, best)
+    const isOver = board.status === 'won' || board.status === 'lost'
+
+    /**
+     * Draws one cell: a number, a flag, a mine, or a button that reveals or flags it.
+     *
+     * @param cell - Cell number to draw.
+     * @returns The cell element.
+     */
+    const cellView = (cell: number) => {
+      const isRevealed = board.revealed.includes(cell)
+      const isMine = board.mines.includes(cell)
+      if (isRevealed || (isOver && isMine)) {
+        if (isMine) return <Text color="#e06c6c">✹ </Text>
+        const n = adjacentMines(board, cell)
+        return <Text color={NUMBER_COLORS[n]}>{n === 0 ? '  ' : `${n} `}</Text>
+      }
+      const label = board.flagged.includes(cell) ? '⚑' : '■'
+      if (isOver) return <Text dimColor>{label} </Text>
+      return (
+        <Button key={`cell:${cell}`} plain onPress={() => pressCell($, cell)}>
+          <Text color={label === '⚑' ? '#e0775a' : '#6b7280'}>{label}</Text>
+        </Button>
+      )
+    }
+
+    const rows = Array.from({ length: board.size }, (_, r) => (
+      <Box flexDirection="row" columnGap={1}>
+        {Array.from({ length: board.size }, (_, c) => cellView(r * board.size + c))}
+      </Box>
+    ))
+
+    const status = board.status === 'won'
+      ? <Text color="#7cc47f" bold>Cleared in {elapsed}s</Text>
+      : board.status === 'lost'
+        ? <Text color="#e06c6c" bold>Boom. {board.revealed.length} cells cleared</Text>
+        : <Text dimColor>💣 {board.mineCount - board.flagged.length} · ⏱ {elapsed}s{record === null ? '' : ` · best ${record}s`}</Text>
+
+    return (
+      <Box flexDirection="column" gap={1}>
+        <Box flexDirection="row" justifyContent="space-between" alignItems="center">
+          {status}
+          <Box flexDirection="row" columnGap={1}>
+            {isOver ? '' : <Button key="flag" label={board.isFlagMode ? '⚑ flagging' : '⚑ flag'} variant={board.isFlagMode ? 'primary' : 'secondary'} onPress={() => toggleFlagMode($)} />}
+            <Button key="new" label="new game" onPress={() => startGame($)} />
+          </Box>
+        </Box>
+        <Box flexDirection="column">{rows}</Box>
+      </Box>
+    )
+  })
+}

package/mods/mini-game/types/index.d.ts

@@ -0,0 +1,21 @@
+// packages/g3n-mods/mods/mini-game/types/index.d.ts
+
+/** A Minesweeper board; cells are numbered row by row from 0. Times are milliseconds since the epoch. */
+export type Game = {
+  size: number
+  mineCount: number
+  /** Empty until the first reveal, which never hits a mine */
+  mines: number[]
+  revealed: number[]
+  flagged: number[]
+  status: 'ready' | 'playing' | 'won' | 'lost'
+  isFlagMode: boolean
+  startedAt: number
+  endedAt?: number
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    'mini-game': { game: Game | null; best: number | null }
+  }
+}

package/mods/tool-timeline/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "tool-timeline",
+  "version": "0.1.0",
+  "description": "Each tool call with its duration; a denied call is struck through next to the call that replaced it.",
+  "author": {
+    "name": "g3ntrovert"
+  },
+  "types": "./types/index.d.ts"
+}

package/mods/tool-timeline/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }