cyber-skills 0.0.0

package/bin/cyber-skills.mts

@@ -0,0 +1,102 @@
+#!/usr/bin/env node --experimental-strip-types
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const packageRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), '..')
+
+function usage() {
+	process.stderr.write(`Usage: cyber-skills <command> [args]
+
+Commands:
+  run-hook <name>              Run a runtime hook by name
+  register-hooks --set <set>   Register agent hooks (init | commit-discipline)
+  inject-commit-discipline     Merge ## Commit Discipline into AGENTS.md
+
+Options:
+  --root <path>                Repo root (default: cwd)
+  --dry-run                    Preview without writing
+  --verbose                    Human-readable status on stderr
+  --commit-skill <name>        Commit helper skill name (inject-commit-discipline)
+`)
+}
+
+const [, , command, ...args] = process.argv
+
+if (!command) {
+	usage()
+	process.exit(1)
+}
+
+function parseCommonArgs(argv: string[]) {
+	return {
+		dryRun: argv.includes('--dry-run'),
+		verbose: argv.includes('--verbose'),
+		root: (() => {
+			const i = argv.indexOf('--root')
+			return i !== -1 ? argv[i + 1]! : process.cwd()
+		})(),
+	}
+}
+
+if (command === 'run-hook') {
+	const hookName = args[0]
+	if (!hookName) {
+		process.stderr.write('Usage: cyber-skills run-hook <name>\n')
+		process.exit(1)
+	}
+
+	const hookFile = path.join(packageRoot, 'hooks', 'runtime', `${hookName}.mts`)
+	if (!fs.existsSync(hookFile)) {
+		process.stderr.write(`Hook not found: ${hookName}\n`)
+		process.exit(1)
+	}
+
+	const { default: run } = await import(pathToFileURL(hookFile).href)
+	await run()
+} else if (command === 'register-hooks') {
+	const { dryRun, verbose, root } = parseCommonArgs(args)
+	const setIdx = args.indexOf('--set')
+	const set = setIdx !== -1 ? args[setIdx + 1] : undefined
+
+	if (!set || (set !== 'init' && set !== 'commit-discipline')) {
+		process.stderr.write('Usage: cyber-skills register-hooks --set init|commit-discipline [--root <path>]\n')
+		process.exit(1)
+	}
+
+	const { registerHooksForSet } = await import(
+		pathToFileURL(path.join(packageRoot, 'hooks', 'register-agent-hooks.mts')).href
+	)
+	const results = registerHooksForSet(set, { root, dryRun })
+
+	if (verbose) {
+		if (dryRun) process.stderr.write('Dry run — no files written.\n\n')
+		for (const r of results) {
+			process.stderr.write(`${r.agent} | ${r.hook} | ${r.status}\n`)
+		}
+	}
+} else if (command === 'inject-commit-discipline') {
+	const { dryRun, verbose, root } = parseCommonArgs(args)
+	const skillIdx = args.indexOf('--commit-skill')
+	const commitSkill = skillIdx !== -1 ? args[skillIdx + 1] : undefined
+
+	if (!commitSkill) {
+		process.stderr.write('Usage: cyber-skills inject-commit-discipline --commit-skill <name>\n')
+		process.exit(1)
+	}
+
+	const { injectCommitDiscipline } = await import(
+		pathToFileURL(path.join(packageRoot, 'hooks', 'inject-commit-discipline.mts')).href
+	)
+	try {
+		const result = injectCommitDiscipline({ root, commitSkill, dryRun, verbose })
+		process.stdout.write(`${JSON.stringify(result)}\n`)
+	} catch (err) {
+		process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`)
+		process.exit(1)
+	}
+} else {
+	process.stderr.write(`Unknown command: ${command}\n`)
+	usage()
+	process.exit(1)
+}

package/hooks/definitions/commit-discipline.mts

@@ -0,0 +1,15 @@
+import { hookCommand } from '../lib/hook-command.mts'
+import type { HookDefinition } from '../register-agent-hooks.mts'
+
+export function getCommitDisciplineHooks(root = process.cwd()): HookDefinition[] {
+	const command = hookCommand('run-hook commit-discipline', root)
+	return [
+		{
+			id: 'commit-discipline',
+			label: 'SessionStart › commit-discipline',
+			command,
+			claude: { event: 'SessionStart' },
+			codex: { event: 'SessionStart' },
+		},
+	]
+}

package/hooks/definitions/init.mts

@@ -0,0 +1,22 @@
+import type { HookDefinition } from '../register-agent-hooks.mts'
+
+const MARK_INTERNAL = 'bash .agents/hooks/mark-internal.sh'
+const INJECT_AUGMENTATIONS = 'bash .agents/hooks/inject-local-augmentations.sh'
+
+export const INIT_HOOKS: HookDefinition[] = [
+	{
+		id: 'mark-internal',
+		label: 'PostToolUse › mark-internal',
+		command: MARK_INTERNAL,
+		claude: { event: 'PostToolUse', matcher: 'Write|Edit' },
+		cursor: { event: 'afterFileEdit' },
+		codex: { event: 'PostToolUse', matcher: 'Write|Edit' },
+	},
+	{
+		id: 'inject-local-augmentations',
+		label: 'SessionStart › inject-local-augmentations',
+		command: INJECT_AUGMENTATIONS,
+		claude: { event: 'SessionStart' },
+		codex: { event: 'SessionStart' },
+	},
+]

package/hooks/inject-commit-discipline.mts

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Inject or update the ## Commit Discipline section in AGENTS.md.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { mergeCommitDisciplineIntoAgentsMd } from './lib/commit-discipline-content.mts'
+
+export interface InjectOptions {
+	root?: string
+	commitSkill: string
+	dryRun?: boolean
+	verbose?: boolean
+}
+
+export function injectCommitDiscipline(options: InjectOptions): { path: string; changed: boolean } {
+	const root = options.root ?? process.cwd()
+	const agentsPath = join(root, 'AGENTS.md')
+
+	if (!existsSync(agentsPath)) {
+		throw new Error('AGENTS.md not found — run the init skill first or create AGENTS.md')
+	}
+
+	const before = readFileSync(agentsPath, 'utf8')
+	const after = mergeCommitDisciplineIntoAgentsMd(before, options.commitSkill)
+	const changed = before !== after
+
+	if (changed && !options.dryRun) {
+		writeFileSync(agentsPath, after)
+	}
+
+	if (options.verbose) {
+		process.stderr.write(
+			changed ? 'Updated ## Commit Discipline in AGENTS.md\n' : '## Commit Discipline already up to date\n',
+		)
+	}
+
+	return { path: agentsPath, changed }
+}
+
+if (process.argv[1] === import.meta.filename) {
+	const args = process.argv.slice(2)
+	const dryRun = args.includes('--dry-run')
+	const verbose = args.includes('--verbose')
+	const skillIdx = args.indexOf('--commit-skill')
+	const rootIdx = args.indexOf('--root')
+	const commitSkill = skillIdx !== -1 ? args[skillIdx + 1] : undefined
+	const root = rootIdx !== -1 ? args[rootIdx + 1] : process.cwd()
+
+	if (!commitSkill) {
+		process.stderr.write(
+			'Usage: inject-commit-discipline.mts --commit-skill <name> [--root <path>] [--dry-run] [--verbose]\n',
+		)
+		process.exit(1)
+	}
+
+	try {
+		const result = injectCommitDiscipline({ root, commitSkill, dryRun, verbose })
+		process.stdout.write(`${JSON.stringify(result)}\n`)
+	} catch (err) {
+		process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`)
+		process.exit(1)
+	}
+}

package/hooks/lib/commit-discipline-content.mts

@@ -0,0 +1,53 @@
+export const COMMIT_DISCIPLINE_HEADING = '## Commit Discipline'
+
+export function formatCommitDisciplineSection(commitSkill: string): string {
+	return `${COMMIT_DISCIPLINE_HEADING}
+
+Commit every self-contained unit of work — code, config, skills — as its own commit before moving on.
+
+- Conventional Commits: \`feat:\`, \`fix:\`, \`refactor:\`, \`test:\`, \`docs:\`, \`chore:\`
+- One concern per commit; never batch unrelated changes
+- Use \`git add -p\` for mixed changes in one file
+- Never commit with red tests; run validation commands first
+- Use the \`${commitSkill}\` skill when committing (staging, splitting, message writing)
+`
+}
+
+/** Extract body of ## Commit Discipline from AGENTS.md, or null if missing. */
+export function parseCommitDisciplineSection(agentsMd: string): string | null {
+	const heading = COMMIT_DISCIPLINE_HEADING
+	const start = agentsMd.indexOf(heading)
+	if (start === -1) return null
+
+	const afterHeading = agentsMd.slice(start + heading.length)
+	const nextHeading = afterHeading.search(/\n## /)
+	const body = nextHeading === -1 ? afterHeading : afterHeading.slice(0, nextHeading)
+	const trimmed = body.trim()
+	return trimmed.length > 0 ? `${heading}\n\n${trimmed}\n` : `${heading}\n`
+}
+
+/** Replace or append the Commit Discipline section in AGENTS.md. */
+export function mergeCommitDisciplineIntoAgentsMd(agentsMd: string, commitSkill: string): string {
+	const section = formatCommitDisciplineSection(commitSkill)
+	const existing = parseCommitDisciplineSection(agentsMd)
+
+	if (existing !== null) {
+		const heading = COMMIT_DISCIPLINE_HEADING
+		const start = agentsMd.indexOf(heading)
+		const afterHeading = agentsMd.slice(start + heading.length)
+		const nextHeading = afterHeading.search(/\n## /)
+		const end = nextHeading === -1 ? agentsMd.length : start + heading.length + nextHeading
+		return agentsMd.slice(0, start) + section.trimEnd() + '\n' + agentsMd.slice(end).replace(/^\n*/, '\n')
+	}
+
+	const skillAugHeading = '## Skill Augmentations'
+	const augIdx = agentsMd.indexOf(skillAugHeading)
+	if (augIdx !== -1) {
+		const afterAug = agentsMd.slice(augIdx)
+		const nextHeading = afterAug.search(/\n## /)
+		const insertAt = nextHeading === -1 ? agentsMd.length : augIdx + nextHeading
+		return `${agentsMd.slice(0, insertAt).trimEnd()}\n\n${section.trimEnd()}\n${agentsMd.slice(insertAt)}`
+	}
+
+	return `${agentsMd.trimEnd()}\n\n${section.trimEnd()}\n`
+}

package/hooks/lib/hook-command.mts

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getPackageRoot } from './package-root.mts'
+
+function getPackageVersion(): string {
+	const pkgPath = join(getPackageRoot(), 'package.json')
+	const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version: string }
+	return pkg.version
+}
+
+/**
+ * Build a hook command string for registration in agent settings.
+ * Prefers local node_modules bin when present (offline/local-agent setups);
+ * otherwise pins npx to the package version that ran register-hooks.
+ */
+export function hookCommand(subcommand: string, root = process.cwd()): string {
+	const localBin = join(root, 'node_modules', '.bin', 'cyber-skills')
+	if (existsSync(localBin)) {
+		return `${localBin} ${subcommand}`
+	}
+	const version = getPackageVersion()
+	return `npx cyber-skills@${version} ${subcommand}`
+}
+
+/** True when an existing registered command refers to the same hook id. */
+export function commandMatchesHook(existing: string, hookId: string, expectedCommand: string): boolean {
+	if (existing === expectedCommand) return true
+	if (hookId === 'commit-discipline' && existing.includes('run-hook commit-discipline')) return true
+	return false
+}

package/hooks/lib/package-root.mts

@@ -0,0 +1,7 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/** Package root (parent of hooks/). */
+export function getPackageRoot(): string {
+	return join(dirname(fileURLToPath(import.meta.url)), '..', '..')
+}

package/hooks/register-agent-hooks.mts

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+/**
+ * Registers agent runtime hooks for detected AI agents (Claude Code, Cursor, Codex).
+ * Idempotent: safe to re-run; only writes when a hook is missing.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getCommitDisciplineHooks } from './definitions/commit-discipline.mts'
+import { INIT_HOOKS } from './definitions/init.mts'
+import { commandMatchesHook } from './lib/hook-command.mts'
+
+interface ClaudeHookEntry {
+	type: string
+	command: string
+}
+interface ClaudeHookGroup {
+	matcher?: string
+	hooks: ClaudeHookEntry[]
+}
+interface ClaudeSettings {
+	hooks?: {
+		PostToolUse?: ClaudeHookGroup[]
+		SessionStart?: ClaudeHookGroup[]
+		[key: string]: ClaudeHookGroup[] | undefined
+	}
+	[key: string]: unknown
+}
+
+interface CursorHookEntry {
+	command: string
+}
+interface CursorSettings {
+	version?: number
+	hooks?: {
+		afterFileEdit?: CursorHookEntry[]
+		sessionStart?: CursorHookEntry[]
+		[key: string]: CursorHookEntry[] | undefined
+	}
+	[key: string]: unknown
+}
+
+export type HookStatus = 'registered' | 'already present' | 'skipped (dir not found)'
+
+export interface HookResult {
+	agent: string
+	hook: string
+	status: HookStatus
+}
+
+export interface RegisterOptions {
+	root?: string
+	dryRun?: boolean
+}
+
+export type HookDefinition = {
+	id: string
+	label: string
+	command: string
+	claude?: { event: 'PostToolUse' | 'SessionStart'; matcher?: string }
+	cursor?: { event: 'afterFileEdit' | 'sessionStart' }
+	codex?: { event: 'PostToolUse' | 'SessionStart'; matcher?: string }
+}
+
+export type HookSet = 'init' | 'commit-discipline'
+
+function readJson<T>(path: string): T {
+	return JSON.parse(readFileSync(path, 'utf8')) as T
+}
+
+function writeJson(path: string, data: unknown) {
+	writeFileSync(path, JSON.stringify(data, null, 2) + '\n')
+}
+
+function commandExistsInGroups(groups: ClaudeHookGroup[], def: HookDefinition): boolean {
+	return groups.some((g) => g.hooks.some((h) => commandMatchesHook(h.command, def.id, def.command)))
+}
+
+function registerClaudeHook(
+	settings: ClaudeSettings,
+	def: HookDefinition,
+	event: 'PostToolUse' | 'SessionStart',
+): boolean {
+	settings.hooks ??= {}
+	settings.hooks[event] ??= []
+
+	if (commandExistsInGroups(settings.hooks[event]!, def)) {
+		return false
+	}
+
+	if (event === 'PostToolUse') {
+		const matcher = def.claude?.matcher ?? 'Write|Edit'
+		const group = settings.hooks.PostToolUse!.find((g) => g.matcher === matcher)
+		if (group) {
+			group.hooks.push({ type: 'command', command: def.command })
+		} else {
+			settings.hooks.PostToolUse!.push({
+				matcher,
+				hooks: [{ type: 'command', command: def.command }],
+			})
+		}
+	} else {
+		if (settings.hooks.SessionStart!.length > 0) {
+			settings.hooks.SessionStart![0]!.hooks.push({ type: 'command', command: def.command })
+		} else {
+			settings.hooks.SessionStart!.push({ hooks: [{ type: 'command', command: def.command }] })
+		}
+	}
+	return true
+}
+
+function registerCursorHook(
+	settings: CursorSettings,
+	def: HookDefinition,
+	event: 'afterFileEdit' | 'sessionStart',
+): boolean {
+	settings.version ??= 1
+	settings.hooks ??= {}
+	settings.hooks[event] ??= []
+
+	const list = settings.hooks[event]!
+	if (list.some((h) => commandMatchesHook(h.command, def.id, def.command))) {
+		return false
+	}
+	list.push({ command: def.command })
+	return true
+}
+
+export function registerAgentHooks(hooks: HookDefinition[], options: RegisterOptions = {}): HookResult[] {
+	const root = options.root ?? process.cwd()
+	const dryRun = options.dryRun ?? false
+	const results: HookResult[] = []
+
+	const claudeDir = join(root, '.claude')
+	const claudeSettingsPath = join(claudeDir, 'settings.json')
+
+	if (existsSync(claudeDir)) {
+		const settings: ClaudeSettings = existsSync(claudeSettingsPath) ? readJson(claudeSettingsPath) : {}
+		let changed = false
+
+		for (const def of hooks) {
+			if (def.claude) {
+				const registered = registerClaudeHook(settings, def, def.claude.event)
+				if (registered) {
+					changed = true
+					results.push({ agent: 'Claude Code', hook: def.label, status: 'registered' })
+				} else {
+					results.push({ agent: 'Claude Code', hook: def.label, status: 'already present' })
+				}
+			}
+		}
+
+		if (changed && !dryRun) {
+			writeJson(claudeSettingsPath, settings)
+		}
+	} else {
+		const claudeHooks = hooks.filter((h) => h.claude)
+		if (claudeHooks.length > 0) {
+			results.push({
+				agent: 'Claude Code',
+				hook: claudeHooks.map((h) => h.label).join(', '),
+				status: 'skipped (dir not found)',
+			})
+		}
+	}
+
+	const cursorDir = join(root, '.cursor')
+	const cursorHooksPath = join(cursorDir, 'hooks.json')
+
+	if (existsSync(cursorDir)) {
+		const settings: CursorSettings = existsSync(cursorHooksPath) ? readJson(cursorHooksPath) : { version: 1 }
+		let changed = false
+
+		for (const def of hooks) {
+			if (def.cursor) {
+				const registered = registerCursorHook(settings, def, def.cursor.event)
+				if (registered) {
+					changed = true
+					results.push({ agent: 'Cursor', hook: def.label, status: 'registered' })
+				} else {
+					results.push({ agent: 'Cursor', hook: def.label, status: 'already present' })
+				}
+			}
+		}
+
+		if (changed && !dryRun) {
+			writeJson(cursorHooksPath, settings)
+		}
+	} else {
+		const cursorHooks = hooks.filter((h) => h.cursor)
+		if (cursorHooks.length > 0) {
+			results.push({
+				agent: 'Cursor',
+				hook: cursorHooks.map((h) => h.label).join(', '),
+				status: 'skipped (dir not found)',
+			})
+		}
+	}
+
+	const codexDir = join(root, '.codex-plugin')
+	const codexHooksPath = join(codexDir, 'hooks.json')
+
+	if (existsSync(codexDir)) {
+		const settings: ClaudeSettings = existsSync(codexHooksPath) ? readJson(codexHooksPath) : {}
+		let changed = false
+
+		for (const def of hooks) {
+			if (def.codex) {
+				const registered = registerClaudeHook(settings, def, def.codex.event)
+				if (registered) {
+					changed = true
+					results.push({ agent: 'Codex', hook: def.label, status: 'registered' })
+				} else {
+					results.push({ agent: 'Codex', hook: def.label, status: 'already present' })
+				}
+			}
+		}
+
+		if (changed && !dryRun) {
+			writeJson(codexHooksPath, settings)
+		}
+	} else {
+		const codexHooks = hooks.filter((h) => h.codex)
+		if (codexHooks.length > 0) {
+			results.push({
+				agent: 'Codex',
+				hook: codexHooks.map((h) => h.label).join(', '),
+				status: 'skipped (dir not found)',
+			})
+		}
+	}
+
+	return results
+}
+
+export function hooksForSet(set: HookSet, root?: string): HookDefinition[] {
+	switch (set) {
+		case 'init':
+			return INIT_HOOKS
+		case 'commit-discipline':
+			return getCommitDisciplineHooks(root)
+	}
+}
+
+export function registerHooksForSet(set: HookSet, options: RegisterOptions = {}): HookResult[] {
+	const root = options.root ?? process.cwd()
+	return registerAgentHooks(hooksForSet(set, root), options)
+}
+
+function printResults(results: HookResult[], dryRun: boolean) {
+	if (dryRun) process.stderr.write('Dry run — no files written.\n\n')
+
+	const agentWidth = Math.max(...results.map((r) => r.agent.length), 'Agent'.length)
+	const hookWidth = Math.max(...results.map((r) => r.hook.length), 'Hook'.length)
+	const statusWidth = Math.max(...results.map((r) => r.status.length), 'Status'.length)
+
+	function pad(s: string, n: number) {
+		return s.padEnd(n)
+	}
+	function row(a: string, h: string, s: string) {
+		return `| ${pad(a, agentWidth)} | ${pad(h, hookWidth)} | ${pad(s, statusWidth)} |`
+	}
+
+	process.stderr.write(`${row('Agent', 'Hook', 'Status')}\n`)
+	process.stderr.write(`|-${'-'.repeat(agentWidth)}-|-${'-'.repeat(hookWidth)}-|-${'-'.repeat(statusWidth)}-|\n`)
+	for (const r of results) {
+		process.stderr.write(`${row(r.agent, r.hook, r.status)}\n`)
+	}
+}
+
+if (process.argv[1] === import.meta.filename) {
+	const args = process.argv.slice(2)
+	const dryRun = args.includes('--dry-run')
+	const verbose = args.includes('--verbose')
+	const setIdx = args.indexOf('--set')
+	const rootIdx = args.indexOf('--root')
+	const set = setIdx !== -1 ? (args[setIdx + 1] as HookSet) : undefined
+	const root = rootIdx !== -1 ? args[rootIdx + 1]! : process.cwd()
+
+	if (!set || (set !== 'init' && set !== 'commit-discipline')) {
+		process.stderr.write(
+			'Usage: register-agent-hooks.mts --set init|commit-discipline [--root <path>] [--dry-run] [--verbose]\n',
+		)
+		process.exit(1)
+	}
+
+	const results = registerHooksForSet(set, { root, dryRun })
+	if (verbose) printResults(results, dryRun)
+}

package/hooks/runtime/commit-discipline.mts

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { formatCommitDisciplineSection, parseCommitDisciplineSection } from '../lib/commit-discipline-content.mts'
+
+async function readStdin(): Promise<string> {
+	const chunks: Buffer[] = []
+	for await (const chunk of process.stdin) {
+		chunks.push(chunk as Buffer)
+	}
+	return Buffer.concat(chunks).toString('utf8').trim()
+}
+
+export default async function run() {
+	const verbose = process.argv.includes('--verbose')
+	const input = await readStdin()
+
+	if (input && verbose) {
+		process.stderr.write(`commit-discipline hook: received ${input.length} bytes on stdin\n`)
+	}
+
+	let context: string
+	const agentsPath = join(process.cwd(), 'AGENTS.md')
+	try {
+		const agentsMd = readFileSync(agentsPath, 'utf8')
+		context = parseCommitDisciplineSection(agentsMd) ?? formatCommitDisciplineSection('commit')
+	} catch {
+		context = formatCommitDisciplineSection('commit')
+	}
+
+	const payload = {
+		hookSpecificOutput: {
+			hookEventName: 'SessionStart',
+			additionalContext: context.trim(),
+		},
+	}
+
+	process.stdout.write(`${JSON.stringify(payload)}\n`)
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "cyber-skills",
+  "version": "0.0.0",
+  "description": "Opinionated skills, hooks, and workflows for AI agents",
+  "keywords": [
+    "agent-skill",
+    "claude-code",
+    "cursor",
+    "codex"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cyberuni/cyber-skills.git"
+  },
+  "author": "unional <homawong@gmail.com>",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cyber-skills": "./bin/cyber-skills.mts"
+  },
+  "files": [
+    "bin",
+    "hooks",
+    "skills"
+  ],
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.15",
+    "@changesets/cli": "^2.29.4",
+    "@commitlint/cli": "^21.0.1",
+    "@commitlint/config-conventional": "^21.0.1",
+    "@repobuddy/biome": "^2.3.1",
+    "@types/node": "^24.10.1",
+    "husky": "^9.1.7",
+    "knip": "^6.14.1",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.7"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "check": "biome check --write .",
+    "cs": "changeset",
+    "format": "biome format --write .",
+    "knip": "knip",
+    "lint": "biome check .",
+    "release": "changeset publish",
+    "render:awesome-list": "tsx skills/update-awesome-list/scripts/render-awesome-list.mts",
+    "test": "vitest run",
+    "test:audit": "tsx skills/audit-skill/scripts/validate-skills.mts",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "verify": "pnpm typecheck && pnpm lint && pnpm test && pnpm test:audit",
+    "version": "changeset version"
+  }
+}