@g3nomaly/g3n-mods 0.1.6 → 0.1.8

package/mods/custom-crab-agents/hooks/register.tsx

@@ -12,6 +12,20 @@ const PANEL = 'agents-panel'
 /** Key prefix of the agents panel's own elements, and the one this section carries so the panel shows it. */
 const PANEL_KEY = 'agents:'
 const ADDON_KEY = 'addon:'
+
+/** Prop the mods viewer adds to every pane it draws; the Claude Code extension draws on the `vscode` surface too, without it. */
+const VIEWER_PROP = 'g3nViewer'
+
+/**
+ * Tells whether the mods viewer asked for this drawing, rather than the Claude Code extension on the same surface.
+ *
+ * @param props - The `Pane` props of the `ui.render` argument.
+ * @returns `true` when the viewer's prop is set.
+ */
+function isViewer(props: object): boolean {
+  return (props as Readonly<Record<string, unknown>>)[VIEWER_PROP] === true
+}
+
 const crabs = atom({ plugin: 'custom-crab-agents', key: 'crabs' } as const, [])
 const planned = atom({ plugin: 'custom-crab-agents', key: 'planned' } as const, [])
 const contextWindow = atom({ plugin: 'custom-crab-agents', key: 'window' } as const, 1_000_000)
@@ -592,7 +606,7 @@ export const register: Register = on => {
     const now = await $.clock.now()
 
     // The viewer draws the crabs with the mod's own view: hand it the cards as data, inside the key the panel looks for.
-    if (e.surface === 'vscode') {
+    if (e.surface === 'vscode' && isViewer(e.props)) {
       const { Input } = $.ui.resolve(e)
       const data: CrabsViewData = {
         crabs: list.map(crab => {

package/mods/delete-guard/.claude-plugin/plugin.json

@@ -5,5 +5,13 @@
   "author": {
     "name": "g3ntrovert"
   },
-  "types": "./types/index.d.ts"
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "showInClaudeCode": {
+      "type": "boolean",
+      "title": "Show in Claude Code",
+      "default": false,
+      "description": "Open this mod's pane in the Claude Code chat when a session starts. The mods viewer shows it either way."
+    }
+  }
 }

package/mods/delete-guard/hooks/register.tsx

@@ -424,6 +424,9 @@ const held: Held[] = []
 /** The card lists every file instead of the first `SHOWN_FILES`. */
 let isExpanded = false
 
+/** The switch stays in the Claude Code chat; else only a waiting delete's card shows there. Set from the plugin options. */
+let isShownInChat = false
+
 /**
  * Turns the guard on or off, for this session and every later one.
  *
@@ -436,12 +439,16 @@ async function setGuard($: EngineInterface, isGuarding: boolean): Promise<void>
 }
 
 /**
- * Shows the switch again once no delete waits: the pane's title goes back from the card's.
+ * Shows the switch again once no delete waits: the pane's title goes back from the card's, or the pane leaves the
+ * Claude Code chat when the switch is not shown there.
  *
  * @param $ - Engine handle the hook received.
  */
 async function showSwitch($: EngineInterface): Promise<void> {
-  if (held.length === 0) await $.ui.open({ id: PANE, title: TITLE }).catch(() => undefined)
+  if (held.length === 0) {
+    if (isShownInChat) await $.ui.open({ id: PANE, title: TITLE }).catch(() => undefined)
+    else await $.ui.close({ id: PANE }).catch(() => undefined)
+  }
   $.ui.invalidate('ui.render')
 }
 
@@ -483,7 +490,8 @@ async function hold($: EngineInterface, card: Omit<Held, 'settle'>, signal: Abor
   const onAbort = (): void => drop('cancel')
   signal?.addEventListener('abort', onAbort, { once: true })
 
-  // The switch's pane is usually open already: retitle and focus it, then redraw it as the card.
+  // A delete waits on an answer, so its card opens in the Claude Code chat whatever the option says: retitle and focus
+  // the switch's pane when it is open already, then redraw it as the card.
   if (held.length === 1) await $.ui.open({ id: PANE, title: HOLD_TITLE, focus: true })
   $.ui.invalidate('ui.render')
 
@@ -508,8 +516,10 @@ async function hold($: EngineInterface, card: Omit<Held, 'settle'>, signal: Abor
  * Registers this mod's `delete-guard` command, its session hook, its Bash tool hook, and its pane: the switch, or the card while a delete waits.
  *
  * @param on - Hook registration function the engine passes in.
+ * @param options - Plugin options; `showInClaudeCode` keeps the switch in the Claude Code chat.
  */
-export const register: Register = on => {
+export const register: Register = (on, options) => {
+  isShownInChat = options.showInClaudeCode === true
   let trash: string | undefined
   let home = ''
 
@@ -524,7 +534,7 @@ export const register: Register = on => {
       description: 'Turn the permanent-delete guard on or off; it stays that way in later sessions',
       argumentHint: 'on | off',
     })
-    void $.ui.open({ id: PANE, title: TITLE })
+    if (isShownInChat) void $.ui.open({ id: PANE, title: TITLE })
     return next(e)
   })
 

package/mods/delete-guard/view/panes.json

@@ -0,0 +1,8 @@
+{
+  "panes": [
+    {
+      "id": "delete-guard",
+      "title": "Delete guard"
+    }
+  ]
+}

package/mods/focus-mode/.claude-plugin/plugin.json

@@ -12,6 +12,12 @@
       "title": "Minutes",
       "default": 25,
       "description": "Length of a focus block in minutes"
+    },
+    "showInClaudeCode": {
+      "type": "boolean",
+      "title": "Show in Claude Code",
+      "default": false,
+      "description": "Open this mod's pane in the Claude Code chat when a session starts. The mods viewer shows it either way."
     }
   }
 }

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

@@ -81,7 +81,7 @@ async function setLength($: EngineInterface, minutes: number): Promise<void> {
 }
 
 /**
- * Starts a block of `minutes`, replacing one already running, and shows the pane.
+ * Starts a block of `minutes`, replacing one already running.
  *
  * @param $ - Engine handle the hook received, see `EngineInterface`.
  * @param minutes - Length of the block in minutes.
@@ -89,7 +89,7 @@ async function setLength($: EngineInterface, minutes: number): Promise<void> {
 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 })
+  $.ui.invalidate('ui.render')
 }
 
 /**
@@ -144,7 +144,8 @@ async function awayBlock($: EngineInterface): Promise<FocusBlock | null> {
  * from asking anything during a block: questions are refused, and so are permission prompts.
  *
  * @param on - Hook registration function the engine passes in.
- * @param options - Plugin options; `minutes` sets the default block length.
+ * @param options - Plugin options; `minutes` sets the default block length, `showInClaudeCode` opens the pane in the
+ *   Claude Code chat at session start.
  */
 export const register: Register = (on, options) => {
   const configured = Number(options.minutes ?? DEFAULT_MINUTES)
@@ -158,7 +159,7 @@ export const register: Register = (on, options) => {
       description: 'Start a focus block in which Claude asks you nothing (the length you set, or the minutes given), or end the running one',
       argumentHint: '[minutes] | end',
     })
-    void $.ui.open({ id: PANE, title: TITLE })
+    if (options.showInClaudeCode === true) void $.ui.open({ id: PANE, title: TITLE })
     $.clock.every(1000, () => void tick($))
     return next(e)
   })
@@ -177,6 +178,8 @@ export const register: Register = (on, options) => {
     // A length typed with the command becomes the one the pane starts with next time.
     if (arg !== '') await setLength($, minutes)
     await startFocus($, minutes)
+    // Typed in the chat, so the countdown shows there too.
+    await $.ui.open({ id: PANE, title: TITLE })
     return { text: `Focus block started: ${minutes} min.` }
   })
 

package/mods/focus-mode/view/panes.json

@@ -0,0 +1,8 @@
+{
+  "panes": [
+    {
+      "id": "focus-mode",
+      "title": "Focus"
+    }
+  ]
+}

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

@@ -1,9 +1,17 @@
 {
   "name": "mini-game",
   "version": "0.1.0",
-  "description": "Minesweeper to play while Claude works.",
+  "description": "Minesweeper and whack-a-mole to play while Claude works.",
   "author": {
     "name": "g3ntrovert"
   },
-  "types": "./types/index.d.ts"
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "showInClaudeCode": {
+      "type": "boolean",
+      "title": "Show in Claude Code",
+      "default": false,
+      "description": "Open this mod's pane in the Claude Code chat when a session starts. The mods viewer shows it either way."
+    }
+  }
 }

package/mods/mini-game/hooks/bubbles.ts

@@ -0,0 +1,27 @@
+// packages/g3n-mods/mods/mini-game/hooks/bubbles.ts
+import type { Sheet } from '../types'
+
+const SIZE = 8
+
+/**
+ * Creates a sheet with every bubble whole.
+ *
+ * @param cleared - Sheets popped clean before this one.
+ * @returns The new sheet, see `Sheet`.
+ */
+export function newSheet(cleared: number): Sheet {
+  return { size: SIZE, popped: [], cleared }
+}
+
+/**
+ * Pops one bubble; popping the last one swaps in a fresh sheet.
+ *
+ * @param sheet - Sheet to pop on, see `Sheet`.
+ * @param bubble - Bubble number, counted row by row from `0`.
+ * @returns The sheet after the pop, or the same sheet when the bubble was already popped.
+ */
+export function pop(sheet: Sheet, bubble: number): Sheet {
+  if (sheet.popped.includes(bubble)) return sheet
+  const popped = [...sheet.popped, bubble]
+  return popped.length === sheet.size * sheet.size ? newSheet(sheet.cleared + 1) : { ...sheet, popped }
+}

package/mods/mini-game/hooks/minesweeper.ts

@@ -0,0 +1,108 @@
+// packages/g3n-mods/mods/mini-game/hooks/minesweeper.ts
+import type { Game } from '../types'
+
+const SIZE = 9
+const MINES = 10
+
+/**
+ * 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`.
+ */
+export 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 }
+}
+
+/**
+ * Flags or unflags a hidden cell while the game is on.
+ *
+ * @param board - Board to flag on, see `Game`.
+ * @param cell - Cell number to flag.
+ * @returns The board after the flag, or the same board when the cell cannot be flagged.
+ */
+export function toggleFlag(board: Game, cell: number): Game {
+  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 }
+}
+
+/**
+ * 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`.
+ */
+export function newGame(now: number): Game {
+  return { size: SIZE, mineCount: MINES, mines: [], revealed: [], flagged: [], status: 'ready', isFlagMode: false, startedAt: now }
+}

package/mods/mini-game/hooks/mole.ts

@@ -0,0 +1,91 @@
+// packages/g3n-mods/mods/mini-game/hooks/mole.ts
+import type { Whack } from '../types'
+
+const SIZE = 4
+export const LIVES = 3
+/** How long the first mole stays up. */
+const START_WINDOW_MS = 1400
+/** How long a mole stays up at the fastest. */
+const MIN_WINDOW_MS = 450
+/** What each hit multiplies the window by, so the game speeds up. */
+const SPEEDUP = 0.94
+
+/**
+ * Creates a game in the `ready` state, with no mole up.
+ *
+ * @returns The new game, see `Whack`.
+ */
+export function newWhack(): Whack {
+  return { size: SIZE, mole: null, moleId: 0, score: 0, lives: LIVES, windowMs: START_WINDOW_MS, status: 'ready' }
+}
+
+/**
+ * Puts the next mole up, in a hole other than the current one.
+ *
+ * @param game - Game to put the mole up in, see `Whack`.
+ * @returns The game with the new mole and its id.
+ */
+function nextMole(game: Whack): Whack {
+  const holes = game.size * game.size
+  const offset = 1 + Math.floor(Math.random() * (holes - 1))
+  const mole = game.mole === null ? Math.floor(Math.random() * holes) : (game.mole + offset) % holes
+  return { ...game, mole, moleId: game.moleId + 1 }
+}
+
+/**
+ * Takes a life; the last one ends the game.
+ *
+ * @param game - Game to take the life from, see `Whack`.
+ * @returns The game after the loss.
+ */
+function loseLife(game: Whack): Whack {
+  const lives = game.lives - 1
+  return lives === 0 ? { ...game, lives, mole: null, status: 'over' } : { ...game, lives }
+}
+
+/**
+ * Starts the game with its first mole up.
+ *
+ * @param game - Game to start, see `Whack`.
+ * @returns The game in the `playing` state, or the same game when it is already on.
+ */
+export function startWhack(game: Whack): Whack {
+  return game.status === 'playing' ? game : nextMole({ ...newWhack(), status: 'playing' })
+}
+
+/**
+ * Whacks one hole: the mole scores and speeds the game up, an empty hole costs a life.
+ *
+ * @param game - Game to whack in, see `Whack`.
+ * @param hole - Hole number, counted row by row from `0`.
+ * @returns The game after the whack, or the same game when it is not on.
+ */
+export function whack(game: Whack, hole: number): Whack {
+  if (game.status !== 'playing') return game
+  if (hole !== game.mole) return loseLife(game)
+  const windowMs = Math.max(MIN_WINDOW_MS, Math.round(game.windowMs * SPEEDUP))
+  return nextMole({ ...game, score: game.score + 1, windowMs })
+}
+
+/**
+ * Lets a mole escape when its time runs out, which costs a life.
+ *
+ * @param game - Game the mole was up in, see `Whack`.
+ * @param moleId - Mole whose time ran out; a mole already whacked or gone is ignored.
+ * @returns The game after the escape, or the same game when that mole is no longer up.
+ */
+export function escape(game: Whack, moleId: number): Whack {
+  if (game.status !== 'playing' || game.moleId !== moleId) return game
+  const after = loseLife(game)
+  return after.status === 'over' ? after : nextMole(after)
+}
+
+/**
+ * Ends a round early, keeping its score.
+ *
+ * @param game - Game to end, see `Whack`.
+ * @returns The game in the `over` state, or the same game when it is not on.
+ */
+export function quit(game: Whack): Whack {
+  return game.status === 'playing' ? { ...game, mole: null, status: 'over' } : game
+}