@g3nomaly/g3n-mods 0.0.0-stage → 0.1.0

package/mods/focus-mode/hooks/register.tsx

@@ -0,0 +1,147 @@
+// packages/g3n-mods/mods/focus-mode/hooks/register.tsx
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register } from 'claude-code'
+
+import type { FocusBlock } from '../types'
+
+const PANE = 'focus-mode'
+const TITLE = 'Focus'
+const block = atom({ plugin: 'focus-mode', key: 'block' } as const, null)
+const finished = atom({ plugin: 'focus-mode', key: 'finished' } as const, 0)
+
+const DEFAULT_MINUTES = 25
+const MAX_SQUARES = 30
+const FILLED = '#e6b450'
+const EMPTY = '#3a3f4b'
+
+/** Remaining time as `mm:ss`, or `h:mm:ss` from an hour up. */
+export function clock(ms: number): string {
+  const total = Math.max(0, Math.ceil(ms / 1000))
+  const h = Math.floor(total / 3600)
+  const m = Math.floor((total % 3600) / 60)
+  const s = total % 60
+  const mm = String(m).padStart(2, '0')
+  const ss = String(s).padStart(2, '0')
+  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`
+}
+
+/** A wall-clock time as `3:10 pm`. */
+function wallTime(epochMs: number): string {
+  const date = new Date(epochMs)
+  const hours = date.getHours()
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  return `${hours % 12 === 0 ? 12 : hours % 12}:${minutes} ${hours < 12 ? 'am' : 'pm'}`
+}
+
+function squaresSvg(count: number, filled: number): string {
+  const size = 10
+  const gap = 3
+  const width = count * (size + gap) - gap
+  const rects = Array.from({ length: count }, (_, i) =>
+    `<rect x="${i * (size + gap)}" y="0" width="${size}" height="${size}" rx="2" fill="${i < filled ? FILLED : EMPTY}"/>`)
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${size}" viewBox="0 0 ${width} ${size}">${rects.join('')}</svg>`
+}
+
+/** Starts a block of `minutes`, replacing one already running, and shows the pane. */
+async function startFocus($: EngineInterface, minutes: number): Promise<void> {
+  const startedAt = await $.clock.now()
+  await update($, block, () => ({ startedAt, endsAt: startedAt + minutes * 60_000, minutes }))
+  await $.ui.open({ id: PANE, title: TITLE })
+}
+
+/** Ends the running block early, or on time when `isDone`. */
+async function endFocus($: EngineInterface, isDone: boolean): Promise<void> {
+  const current = await read($, block)
+  if (current === null) return
+  await update($, block, () => null)
+  $.ui.status(undefined)
+  if (isDone) {
+    await update($, finished, n => n + 1)
+    $.ui.toast(`Focus block done: ${current.minutes} min`)
+    await $.ui.notify(`${current.minutes} minutes of focus done. Take a break.`, { title: 'Focus block done' }).catch(() => undefined)
+  }
+}
+
+/** Once a second: ends a block whose time is up, else moves the countdown on. */
+async function tick($: EngineInterface): Promise<void> {
+  const current = await read($, block)
+  if (current === null) return
+  const now = await $.clock.now()
+  if (now >= current.endsAt) {
+    await endFocus($, true)
+    return
+  }
+  $.ui.status(`focus ${clock(current.endsAt - now)}`)
+  $.ui.invalidate('ui.render')
+}
+
+export const register: Register = (on, options) => {
+  const configured = Number(options.minutes ?? DEFAULT_MINUTES)
+  const defaultMinutes = Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_MINUTES
+
+  on('session.start', async ($, e, next) => {
+    await $.command.register({
+      name: 'focus-mode',
+      description: `Start a focus block (${defaultMinutes} min by default), or end the running one`,
+      argumentHint: '[minutes] | end',
+    })
+    $.clock.every(1000, () => void tick($))
+    return next(e)
+  })
+
+  on('command.run', { command: 'focus-mode' }, async ($, e) => {
+    const arg = e.args.trim()
+    if (arg === 'end' || arg === 'stop') {
+      await endFocus($, false)
+      return { text: 'Focus block ended.' }
+    }
+    const minutes = arg === '' ? defaultMinutes : Number(arg)
+    if (!Number.isFinite(minutes) || minutes <= 0 || minutes > 600) {
+      return { text: `"${arg}" is not a number of minutes. Use /focus-mode 25, or /focus-mode end.` }
+    }
+    await startFocus($, minutes)
+    return { text: `Focus block started: ${minutes} min.` }
+  })
+
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const { Box, Text, Button } = $.ui.resolve(e)
+    const current = await read($, block)
+
+    if (current === null) {
+      const done = await read($, finished)
+      return (
+        <Box flexDirection="row" justifyContent="space-between" alignItems="center">
+          <Text dimColor>{done > 0 ? `${done} focus block${done === 1 ? '' : 's'} done this session.` : 'No focus block running.'}</Text>
+          <Button key="start" label={`start ${defaultMinutes} min`} variant="primary" onPress={() => startFocus($, defaultMinutes)} />
+        </Box>
+      )
+    }
+
+    const now = await $.clock.now()
+    const remaining = current.endsAt - now
+    const count = Math.min(MAX_SQUARES, Math.max(1, Math.round(current.minutes)))
+    const filled = Math.ceil((remaining / (current.endsAt - current.startedAt)) * count)
+    const squares = e.surface === 'terminal'
+      ? (
+          <Text>
+            <Text color={FILLED}>{'■'.repeat(filled)}</Text>
+            <Text color={EMPTY}>{'■'.repeat(count - filled)}</Text>
+          </Text>
+        )
+      : (() => {
+          const { Svg } = $.ui.resolve(e)
+          return <Svg source={squaresSvg(count, filled)} alt={`${clock(remaining)} left`} width={count * 13 - 3} height={10} />
+        })()
+
+    return (
+      <Box flexDirection="row" alignItems="center" columnGap={3}>
+        <Text bold>{clock(remaining)}</Text>
+        <Box flexDirection="column" flexGrow={1} gap={0}>
+          {squares}
+          <Text dimColor>focus block · {current.minutes} min · ends {wallTime(current.endsAt)}</Text>
+        </Box>
+        <Button key="end" label="end focus" onPress={() => endFocus($, false)} />
+      </Box>
+    )
+  })
+}

package/mods/focus-mode/types/index.d.ts

@@ -0,0 +1,14 @@
+// packages/g3n-mods/mods/focus-mode/types/index.d.ts
+
+/** A running focus block; times are milliseconds since the epoch. */
+export type FocusBlock = {
+  startedAt: number
+  endsAt: number
+  minutes: number
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    'focus-mode': { block: FocusBlock | null; finished: number }
+  }
+}

package/mods/handoff/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "handoff",
+  "version": "0.1.0",
+  "description": "Writes a handoff with the handoff skill, clears the session, and starts the fresh one with your next prompt.",
+  "author": {
+    "name": "g3ntrovert"
+  },
+  "types": "./types/index.d.ts"
+}

package/mods/handoff/hooks/hooks.json

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

package/mods/handoff/hooks/register.tsx

@@ -0,0 +1,119 @@
+// packages/g3n-mods/mods/handoff/hooks/register.tsx
+import { atom, update } from 'claude-code'
+import type { EngineInterface, Register } from 'claude-code'
+
+import type { PendingHandoff } from '../types'
+
+const pending = atom({ plugin: 'handoff', key: 'pending' } as const, null)
+
+const STORE_KEY = 'pending'
+const SKILL_PATH = '.claude/skills/handoff/SKILL.md'
+/** A handoff older than this is dropped instead of attached. */
+const MAX_AGE_MS = 24 * 60 * 60 * 1000
+
+/** The handoff skill's instructions, used when no `handoff` skill is installed. */
+const FALLBACK_SKILL = [
+  'Write a handoff document summarising the current conversation so a fresh agent can continue the work.',
+  'Include a "suggested skills" section, which suggests skills that the agent should invoke.',
+  'Do not duplicate content already captured in other artifacts (specs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead.',
+  'Redact any sensitive information, such as API keys, passwords, or personally identifiable information.',
+  'If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly.',
+].join('\n\n')
+
+function withoutFrontmatter(text: string): string {
+  return text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim()
+}
+
+function isPendingHandoff(value: unknown): value is PendingHandoff {
+  return typeof value === 'object' && value !== null
+    && 'text' in value && typeof value.text === 'string'
+    && 'path' in value && typeof value.path === 'string'
+    && 'createdAt' in value && typeof value.createdAt === 'number'
+}
+
+/** The `handoff` skill's body from the project, else the user's skills, else the built-in copy. */
+async function loadSkill($: EngineInterface): Promise<string> {
+  const root = await $.session.root()
+  const home = await $.env.get('HOME')
+  for (const path of [`${root}/${SKILL_PATH}`, home === undefined ? '' : `${home}/${SKILL_PATH}`]) {
+    if (path !== '' && (await $.fs.exists(path))) return withoutFrontmatter(await $.fs.read(path))
+  }
+  return FALLBACK_SKILL
+}
+
+/** Absolute path in the OS temporary folder for a handoff written at `now`. */
+async function documentPath($: EngineInterface, now: number): Promise<string> {
+  const tmp = ((await $.env.get('TMPDIR')) ?? '/tmp').replace(/\/$/, '')
+  const stamp = new Date(now).toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  return `${tmp}/claude-handoff-${stamp}.md`
+}
+
+/** Runs /clear once the session is idle, after the command that asked for it has answered. */
+async function clearSession($: EngineInterface): Promise<void> {
+  await $.command.run({ command: 'clear' }).catch(() => $.ui.toast('Run /clear to start the fresh session; the handoff waits for your next prompt.'))
+}
+
+/** The handoff waiting for the next prompt, dropping one that has gone stale. */
+async function takePending($: EngineInterface): Promise<PendingHandoff | undefined> {
+  const stored = await $.store.get(STORE_KEY)
+  if (!isPendingHandoff(stored)) return undefined
+  await $.store.delete(STORE_KEY)
+  await update($, pending, () => null)
+  $.ui.status(undefined)
+  const now = await $.clock.now()
+  return now - stored.createdAt > MAX_AGE_MS ? undefined : stored
+}
+
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    await $.command.register({
+      name: 'handoff-new',
+      description: 'Write a handoff, clear the session, and start the fresh one with your next prompt',
+      argumentHint: 'what the next session is for',
+    })
+    const stored = await $.store.get(STORE_KEY)
+    if (isPendingHandoff(stored)) {
+      await update($, pending, () => stored)
+      $.ui.status('handoff ready: your next prompt starts with it')
+    }
+    return next(e)
+  })
+
+  on('command.run', { command: 'handoff-new' }, async ($, e) => {
+    const skill = await loadSkill($)
+    const focus = e.args.trim()
+    const prompt = [
+      'Write the handoff document these instructions describe, for the conversation so far.',
+      'You cannot use tools. Answer with the document as Markdown and nothing else; it is saved for you.',
+      focus.length > 0 ? `The next session will be used for: ${focus}` : '',
+      '<instructions>',
+      skill,
+      '</instructions>',
+    ].filter(line => line.length > 0).join('\n\n')
+
+    $.ui.toast('Writing the handoff…')
+    const written = await $.model.fork({ prompt })
+    if (!written.isAnswered) {
+      return { text: `The handoff was not written (${written.reason}). The conversation is unchanged.`, exitCode: 1 }
+    }
+
+    const now = await $.clock.now()
+    const path = await documentPath($, now)
+    await $.fs.write(path, written.text)
+    const handoff: PendingHandoff = { text: written.text, path, createdAt: now }
+    await $.store.set(STORE_KEY, handoff)
+    await update($, pending, () => handoff)
+    $.ui.status('handoff ready: your next prompt starts with it')
+    $.clock.after(0, () => void clearSession($))
+    return { text: `Handoff saved to ${path}. The conversation clears now; your next prompt starts the fresh session with it.` }
+  })
+
+  on('prompt.submit', async ($, e, next) => {
+    if (e.text.trimStart().startsWith('/')) return next(e)
+    const handoff = await takePending($)
+    if (handoff === undefined) return next(e)
+    $.ui.toast('Handoff attached to this prompt')
+    const context = `Handoff from the previous session, saved at ${handoff.path}:\n\n${handoff.text}`
+    return next({ ...e, context: [...(e.context ?? []), context] })
+  }).catch(($, e, next) => next(e))
+}

package/mods/handoff/types/index.d.ts

@@ -0,0 +1,15 @@
+// packages/g3n-mods/mods/handoff/types/index.d.ts
+
+/** A handoff written and waiting for the next prompt; `createdAt` is milliseconds since the epoch. */
+export type PendingHandoff = {
+  text: string
+  /** Absolute path the document was saved to */
+  path: string
+  createdAt: number
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    handoff: { pending: PendingHandoff | null }
+  }
+}

package/mods/hide-personal-data/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "hide-personal-data",
+  "version": "0.1.0",
+  "description": "Masks names, emails and other personal data in replies; hover to show them.",
+  "author": {
+    "name": "g3ntrovert"
+  },
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "names": {
+      "type": "string",
+      "title": "Names",
+      "default": "",
+      "description": "Extra names to mask, separated by commas"
+    }
+  }
+}

package/mods/hide-personal-data/hooks/hooks.json

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

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

@@ -0,0 +1,163 @@
+// 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
+
+function digitCount(text: string): number {
+  return text.replace(/\D/g, '').length
+}
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * Finds personal data in a text: emails, phone numbers, IBANs, card numbers
+ * and names, the latter from `names` and from common first names followed by
+ * a surname. Overlapping matches keep the earlier, longer one.
+ *
+ * @param names - Exact names to mask wherever they occur, e.g. the git user's
+ * @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
+}
+
+/** Inline Markdown a line drawn as plain text would show raw: emphasis marks and heading hashes. */
+function plain(line: string): string {
+  return line.replace(/^#{1,6}\s+/, '').replace(/(\*\*|__|`)/g, '')
+}
+
+/** Reads the git user's name and email, the names most likely to show up in replies. */
+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
+}
+
+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[] = []
+    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"] }