@isentinel/hooks 1.2.0

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026-PRESENT Christopher Buss <christopher.buss@pm.me>
+
+Copyright for portions of this project are held by Anthony Fu 2025, as part of
+antfu/skills. All other copyright are held by Christopher Buss
+<christopher.buss@pm.me>, 2026.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,85 @@
+# Roblox Skills & Claude Code Extensions
+
+Personal collection of [Agent Skills](https://agentskills.io/home), hooks, and
+plugins for Claude Code, focused on Roblox development.
+
+This started as a fork of [antfu/skills](https://github.com/antfu/skills). I'm
+repurposing it for my own workflow but keeping it open source in case others
+find it useful.
+
+## What's here
+
+- **Skills** - Agent skills for Roblox tooling, Luau, and related ecosystems
+- **Hooks** - Custom Claude Code hooks for my workflow
+- **Plugins** - Any other extensions I end up building
+
+## Installation
+
+```bash
+pnpx skills add christopher-buss/skills -skill='*'
+```
+
+Or install everything globally:
+
+```bash
+pnpx skills add christopher-buss/skills -skill='*' -g
+```
+
+More on the CLI at [skills](https://github.com/vercel-labs/skills).
+
+## Skills
+
+### Hand-maintained
+
+Manually written with personal preferences and best practices.
+
+| Skill                         | Description                                                   |
+| ----------------------------- | ------------------------------------------------------------- |
+| [isentinel](skills/isentinel) | isentinel's opinionated preferences for roblox-ts development |
+| [roblox-ts](skills/roblox-ts) | TypeScript to Roblox Lua transpiler                           |
+| [test-driven-development](skills/test-driven-development) | How to write tests and design for testability in Roblox projects |
+| [ecs-design](skills/ecs-design) | Best practices for designing Entity Component Systems in Roblox    |
+
+### Generated from documentation
+
+Generated from official docs.
+
+| Skill                             | Description                                   | Source                                                        |
+| --------------------------------- | --------------------------------------------- | ------------------------------------------------------------- |
+| [jecs](skills/jecs)               | Entity Component System for Roblox            | [Ukendio/jecs](https://github.com/Ukendio/jecs)               |
+| [pnpm](skills/pnpm)               | Fast, disk-efficient package manager          | [pnpm/pnpm.io](https://github.com/pnpm/pnpm.io)               |
+| [roblox-ts](skills/robloxTs)      | TypeScript to Roblox Lua transpiler           | [roblox-ts/roblox-ts](https://github.com/roblox-ts/roblox-ts) |
+| [superpowers](skills/superpowers) | Agent workflow skills (customized for Roblox) | [obra/superpowers](https://github.com/obra/superpowers)       |
+
+### Vendored
+
+Synced from external repos that maintain their own skills.
+
+| Skill                                   | Description                          | Source                                                  |
+| --------------------------------------- | ------------------------------------ | ------------------------------------------------------- |
+| [humanizer](skills/humanizer)           | Remove AI writing patterns from text | [blader/humanizer](https://github.com/blader/humanizer) |
+| [writing-skills](skills/writing-skills) | How to write agent skills            | [obra/superpowers](https://github.com/obra/superpowers) |
+
+## Usage
+
+See [AGENTS.md](AGENTS.md) for how skills are generated and maintained.
+
+## Adding your own
+
+1. Fork this repo
+2. `pnpm install`
+3. Update `meta.ts` with your projects
+4. `nr start cleanup` to clear existing submodules
+5. `nr start init` to clone fresh
+6. `nr start sync` for vendored skills
+7. Have your agent generate skills one project at a time
+
+## Attribution
+
+Forked from [Anthony Fu's skills](https://github.com/antfu/skills). The original
+project's approach of using git submodules to reference source documentation is
+clever - skills stay current with upstream changes without manual updates.
+
+## License
+
+[MIT](LICENSE.md). Vendored skills keep their original licenses.

package/dist/events.d.mts

@@ -0,0 +1,47 @@
+//#region node_modules/.pnpm/@constellos+claude-code-kit@0.4.0/node_modules/@constellos/claude-code-kit/dist/types/hooks/base.d.ts
+/**
+ * Base output fields available for all hook events
+ */
+interface BaseHookOutput {
+  /**
+   * Whether Claude should continue after hook execution.
+   * Setting to false will terminate execution and require user input.
+   * @default true
+   */
+  continue?: boolean;
+  /** Message shown to user when continue is false */
+  stopReason?: string;
+  /**
+   * Hide stdout from transcript mode.
+   * Useful for suppressing verbose output.
+   * @default false
+   */
+  suppressOutput?: boolean;
+  /**
+   * Optional warning message shown to the user.
+   * Useful when "continue" is true but a message to the user is still needed.
+   */
+  systemMessage?: string;
+}
+//#endregion
+//#region node_modules/.pnpm/@constellos+claude-code-kit@0.4.0/node_modules/@constellos/claude-code-kit/dist/types/hooks/events.d.ts
+/**
+ * PostToolUse hook output
+ */
+type PostToolUseHookOutput = BaseHookOutput & ({
+  decision: undefined;
+  reason?: string;
+  hookSpecificOutput?: {
+    hookEventName: "PostToolUse";
+    additionalContext?: string;
+  };
+} | {
+  decision: "block";
+  reason?: string; /** Required when decision is "block" */
+  hookSpecificOutput: {
+    hookEventName: "PostToolUse"; /** Required when decision is "block" */
+    additionalContext: string;
+  };
+});
+//#endregion
+export { PostToolUseHookOutput as t };

package/dist/hooks/clear-lint-state.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/clear-lint-state.mjs

@@ -0,0 +1,13 @@
+import { clearEditedFiles, clearLintAttempts, clearStopAttempts } from "../scripts/lint.mjs";
+import { clearTypecheckStopAttempts } from "../scripts/type-check.mjs";
+import { t as readStdinJson } from "../io.mjs";
+
+//#region hooks/clear-lint-state.ts
+const input = await readStdinJson();
+clearLintAttempts();
+clearStopAttempts();
+clearTypecheckStopAttempts();
+clearEditedFiles(input.session_id);
+
+//#endregion
+export {  };

package/dist/hooks/lint-guard.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/lint-guard.mjs

@@ -0,0 +1,15 @@
+import { isProtectedFile } from "../scripts/lint.mjs";
+import { n as writeStdoutJson, t as readStdinJson } from "../io.mjs";
+import { basename } from "node:path";
+
+//#region hooks/lint-guard.ts
+const input = await readStdinJson();
+if (input.tool_name === "Write" || input.tool_name === "Edit") {
+	if (isProtectedFile(basename(input.tool_input.file_path))) writeStdoutJson({
+		decision: "block",
+		reason: "Modifying linter config is forbidden. Report to user if a rule blocks your task."
+	});
+}
+
+//#endregion
+export {  };

package/dist/hooks/lint-stop.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/lint-stop.mjs

@@ -0,0 +1,39 @@
+import { findSourceRoot, getTransitiveDependents, isLintableFile, lint, readEditedFiles, readLintAttempts, readSettings, readStopAttempts, stopDecision, writeStopAttempts } from "../scripts/lint.mjs";
+import { n as writeStdoutJson, t as readStdinJson } from "../io.mjs";
+import { resolve } from "node:path";
+import process from "node:process";
+
+//#region hooks/lint-stop.ts
+const settings = readSettings();
+if (!settings.lint) process.exit(0);
+const SESSION_ID = (await readStdinJson()).session_id;
+const editedFiles = readEditedFiles(SESSION_ID);
+if (editedFiles.length === 0) process.exit(0);
+const dependents = /* @__PURE__ */ new Set();
+const seen = /* @__PURE__ */ new Set();
+for (const file of editedFiles) {
+	const sourceRoot = findSourceRoot(resolve(file));
+	if (sourceRoot === void 0 || seen.has(sourceRoot)) continue;
+	seen.add(sourceRoot);
+	for (const dependent of getTransitiveDependents(editedFiles, sourceRoot, settings.runner)) dependents.add(dependent);
+}
+const files = [...new Set([...editedFiles, ...dependents])].filter((file) => isLintableFile(file));
+if (files.length === 0) process.exit(0);
+const errorFiles = [];
+for (const file of files) if (lint(file, ["--fix"], settings) !== void 0) errorFiles.push(file);
+const result = stopDecision({
+	errorFiles,
+	lintAttempts: readLintAttempts(),
+	maxLintAttempts: settings.maxLintAttempts,
+	stopAttempts: readStopAttempts()
+});
+if (result === void 0) process.exit(0);
+if (result.resetStopAttempts) {
+	writeStopAttempts(0);
+	process.exit(0);
+}
+writeStopAttempts(readStopAttempts() + 1);
+writeStdoutJson(result);
+
+//#endregion
+export {  };

package/dist/hooks/lint.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/lint.mjs

@@ -0,0 +1,28 @@
+import { lint, readLintAttempts, readSettings, writeEditedFile, writeLintAttempts } from "../scripts/lint.mjs";
+import { n as writeStdoutJson, t as readStdinJson } from "../io.mjs";
+import process from "node:process";
+
+//#region hooks/lint.ts
+const settings = readSettings();
+if (!settings.lint) process.exit(0);
+const input = await readStdinJson();
+if (input.tool_name !== "Write" && input.tool_name !== "Edit") process.exit(0);
+function run(filePath) {
+	const attempts = readLintAttempts();
+	const result = lint(filePath, ["--fix"], settings);
+	if (result !== void 0) {
+		const count = (attempts[filePath] ?? 0) + 1;
+		attempts[filePath] = count;
+		writeLintAttempts(attempts);
+		if (count >= settings.maxLintAttempts && result.hookSpecificOutput) result.hookSpecificOutput.additionalContext = `CRITICAL: ${filePath} failed linting ${count} times. STOP editing this file and report lint errors to user.\n${result.hookSpecificOutput.additionalContext}`;
+		writeStdoutJson(result);
+	} else if (filePath in attempts) {
+		delete attempts[filePath];
+		writeLintAttempts(attempts);
+	}
+}
+run(input.tool_input.file_path);
+writeEditedFile(input.session_id, input.tool_input.file_path);
+
+//#endregion
+export {  };

package/dist/hooks/type-check-stop.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/type-check-stop.mjs

@@ -0,0 +1,48 @@
+import { findSourceRoot, getTransitiveDependents, readEditedFiles, readLintAttempts, readSettings } from "../scripts/lint.mjs";
+import { isTypeCheckable, readTypecheckStopAttempts, resolveTsconfig, runTypeCheck, typecheckStopDecision, writeTypecheckStopAttempts } from "../scripts/type-check.mjs";
+import { n as writeStdoutJson, t as readStdinJson } from "../io.mjs";
+import { join, resolve } from "node:path";
+import process from "node:process";
+
+//#region hooks/type-check-stop.ts
+const settings = readSettings();
+if (!settings.typecheck) process.exit(0);
+const SESSION_ID = (await readStdinJson()).session_id;
+const PROJECT_ROOT = process.env["CLAUDE_PROJECT_DIR"] ?? process.cwd();
+const editedFiles = readEditedFiles(SESSION_ID);
+if (editedFiles.length === 0) process.exit(0);
+const allFiles = new Set(editedFiles);
+const seenRoots = /* @__PURE__ */ new Set();
+for (const file of editedFiles) {
+	const sourceRoot = findSourceRoot(resolve(file));
+	if (sourceRoot === void 0 || seenRoots.has(sourceRoot)) continue;
+	seenRoots.add(sourceRoot);
+	for (const dependent of getTransitiveDependents(editedFiles, sourceRoot, settings.runner)) allFiles.add(dependent);
+}
+const files = [...allFiles].filter((file) => isTypeCheckable(file));
+if (files.length === 0) process.exit(0);
+const errorFiles = [];
+for (const file of files) {
+	const tsconfig = resolveTsconfig(join(PROJECT_ROOT, file), PROJECT_ROOT);
+	if (tsconfig === void 0) continue;
+	const output = runTypeCheck(tsconfig, settings.runner, settings.typecheckArgs);
+	if (output !== void 0) {
+		if (/error TS/i.test(output)) errorFiles.push(file);
+	}
+}
+const result = typecheckStopDecision({
+	errorFiles,
+	lintAttempts: readLintAttempts(),
+	maxLintAttempts: settings.maxLintAttempts,
+	stopAttempts: readTypecheckStopAttempts()
+});
+if (result === void 0) process.exit(0);
+if (result.resetStopAttempts) {
+	writeTypecheckStopAttempts(0);
+	process.exit(0);
+}
+writeTypecheckStopAttempts(readTypecheckStopAttempts() + 1);
+writeStdoutJson(result);
+
+//#endregion
+export {  };

package/dist/hooks/type-check.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/hooks/type-check.mjs

@@ -0,0 +1,29 @@
+import { readLintAttempts, readSettings, writeEditedFile, writeLintAttempts } from "../scripts/lint.mjs";
+import { typeCheck } from "../scripts/type-check.mjs";
+import { n as writeStdoutJson, t as readStdinJson } from "../io.mjs";
+import process from "node:process";
+
+//#region hooks/type-check.ts
+const settings = readSettings();
+if (!settings.typecheck) process.exit(0);
+const input = await readStdinJson();
+if (input.tool_name !== "Write" && input.tool_name !== "Edit") process.exit(0);
+function run(filePath) {
+	const attempts = readLintAttempts();
+	const result = typeCheck(filePath, settings);
+	if (result !== void 0) {
+		const count = (attempts[filePath] ?? 0) + 1;
+		attempts[filePath] = count;
+		writeLintAttempts(attempts);
+		if (count >= settings.maxLintAttempts && result.hookSpecificOutput) result.hookSpecificOutput.additionalContext = `CRITICAL: ${filePath} failed type-check ${count} times. STOP editing this file and report type errors to user.\n${result.hookSpecificOutput.additionalContext}`;
+		writeStdoutJson(result);
+	} else if (filePath in attempts) {
+		delete attempts[filePath];
+		writeLintAttempts(attempts);
+	}
+}
+run(input.tool_input.file_path);
+writeEditedFile(input.session_id, input.tool_input.file_path);
+
+//#endregion
+export {  };

package/dist/io.mjs

@@ -0,0 +1,29 @@
+import process from "node:process";
+import { Buffer } from "node:buffer";
+
+//#region hooks/io.ts
+async function readStdinJson() {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		process.stdin.on("end", () => {
+			try {
+				const data = Buffer.concat(chunks).toString("utf8");
+				resolve(JSON.parse(data));
+			} catch (err) {
+				reject(/* @__PURE__ */ new Error(`Failed to parse JSON input: ${err}`));
+			}
+		});
+		process.stdin.on("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`Failed to read stdin: ${error}`));
+		});
+	});
+}
+function writeStdoutJson(output) {
+	process.stdout.write(`${JSON.stringify(output)}\n`);
+}
+
+//#endregion
+export { writeStdoutJson as n, readStdinJson as t };

package/dist/scripts/lint.d.mts

@@ -0,0 +1,58 @@
+import { t as PostToolUseHookOutput } from "../events.mjs";
+
+//#region scripts/lint.d.ts
+interface LintSettings {
+  cacheBust: Array<string>;
+  eslint: boolean;
+  lint: boolean;
+  maxLintAttempts: number;
+  oxlint: boolean;
+  runner: string;
+  typecheck: boolean;
+  typecheckArgs: Array<string>;
+}
+type DependencyGraph = Record<string, Array<string>>;
+declare function isProtectedFile(filename: string): boolean;
+declare function readEditedFiles(sessionId: string): Array<string>;
+declare function writeEditedFile(sessionId: string, filePath: string): void;
+declare function clearEditedFiles(sessionId: string): void;
+declare function getTransitiveDependents(files: Array<string>, sourceRoot: string, runner?: string): Array<string>;
+declare const DEFAULT_CACHE_BUST: string[];
+interface StopDecisionResult {
+  decision?: "block";
+  reason?: string;
+  resetStopAttempts?: true;
+}
+interface StopDecisionInput {
+  errorFiles: Array<string>;
+  lintAttempts: Record<string, number>;
+  maxLintAttempts: number;
+  stopAttempts: number;
+}
+declare function readSettings(): LintSettings;
+declare function getChangedFiles(): Array<string>;
+declare function isLintableFile(filePath: string, extensions?: string[]): boolean;
+declare function findEntryPoints(sourceRoot: string): Array<string>;
+declare function getDependencyGraph(sourceRoot: string, entryPoints: Array<string>, runner?: string): DependencyGraph;
+declare function invertGraph(graph: DependencyGraph, target: string): Array<string>;
+declare function findSourceRoot(filePath: string): string | undefined;
+declare function readLintAttempts(): Record<string, number>;
+declare function writeLintAttempts(attempts: Record<string, number>): void;
+declare function readStopAttempts(): number;
+declare function writeStopAttempts(count: number): void;
+declare function stopDecision(input: StopDecisionInput): StopDecisionResult | undefined;
+declare function clearStopAttempts(): void;
+declare function clearLintAttempts(): void;
+declare function resolveBustFiles(patterns: Array<string>): Array<string>;
+declare function shouldBustCache(patterns: Array<string>): boolean;
+declare function clearCache(): void;
+declare function invalidateCacheEntries(filePaths: Array<string>): void;
+declare function runOxlint(filePath: string, extraFlags?: Array<string>, runner?: string): string | undefined;
+declare function runEslint(filePath: string, extraFlags?: Array<string>, runner?: string): string | undefined;
+declare function restartDaemon(runner?: string): void;
+declare function formatErrors(output: string): Array<string>;
+declare function buildHookOutput(filePath: string, errors: Array<string>): PostToolUseHookOutput;
+declare function lint(filePath: string, extraFlags?: Array<string>, settings?: LintSettings): PostToolUseHookOutput | undefined;
+declare function main(targets: Array<string>, settings?: LintSettings): void;
+//#endregion
+export { DEFAULT_CACHE_BUST, DependencyGraph, LintSettings, StopDecisionResult, buildHookOutput, clearCache, clearEditedFiles, clearLintAttempts, clearStopAttempts, findEntryPoints, findSourceRoot, formatErrors, getChangedFiles, getDependencyGraph, getTransitiveDependents, invalidateCacheEntries, invertGraph, isLintableFile, isProtectedFile, lint, main, readEditedFiles, readLintAttempts, readSettings, readStopAttempts, resolveBustFiles, restartDaemon, runEslint, runOxlint, shouldBustCache, stopDecision, writeEditedFile, writeLintAttempts, writeStopAttempts };

package/dist/scripts/lint.mjs

@@ -0,0 +1,398 @@
+import { createFromFile } from "file-entry-cache";
+import { execSync, spawn } from "node:child_process";
+import { existsSync, globSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import process from "node:process";
+
+//#region scripts/lint.ts
+const PROTECTED_PATTERNS = [
+	"eslint.config.",
+	"oxlint.config.",
+	".eslintrc",
+	".oxlintrc."
+];
+function isProtectedFile(filename) {
+	return PROTECTED_PATTERNS.some((pattern) => filename.startsWith(pattern) || filename === pattern);
+}
+const LINT_STATE_PATH = ".claude/state/lint-attempts.json";
+const STOP_STATE_PATH = ".claude/state/stop-attempts.json";
+const EDITED_FILES_PATH = ".claude/state/edited-files.json";
+function readEditedFiles(sessionId) {
+	if (!existsSync(EDITED_FILES_PATH)) return [];
+	try {
+		return JSON.parse(readFileSync(EDITED_FILES_PATH, "utf-8"))[sessionId] ?? [];
+	} catch {
+		return [];
+	}
+}
+function writeEditedFile(sessionId, filePath) {
+	let state = {};
+	if (existsSync(EDITED_FILES_PATH)) try {
+		state = JSON.parse(readFileSync(EDITED_FILES_PATH, "utf-8"));
+	} catch {
+		state = {};
+	}
+	const files = state[sessionId] ?? [];
+	if (!files.includes(filePath)) files.push(filePath);
+	state[sessionId] = files;
+	mkdirSync(dirname(EDITED_FILES_PATH), { recursive: true });
+	writeFileSync(EDITED_FILES_PATH, JSON.stringify(state));
+}
+function clearEditedFiles(sessionId) {
+	if (!existsSync(EDITED_FILES_PATH)) return;
+	try {
+		const state = JSON.parse(readFileSync(EDITED_FILES_PATH, "utf-8"));
+		delete state[sessionId];
+		if (Object.keys(state).length === 0) unlinkSync(EDITED_FILES_PATH);
+		else writeFileSync(EDITED_FILES_PATH, JSON.stringify(state));
+	} catch {
+		unlinkSync(EDITED_FILES_PATH);
+	}
+}
+function getTransitiveDependents(files, sourceRoot, runner = DEFAULT_SETTINGS.runner) {
+	const entryPoints = findEntryPoints(sourceRoot);
+	if (entryPoints.length === 0) return [];
+	const graph = getDependencyGraph(sourceRoot, entryPoints, runner);
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [];
+	for (const file of files) {
+		const relativePath = relative(sourceRoot, resolve(file)).replaceAll("\\", "/");
+		if (!visited.has(relativePath)) {
+			visited.add(relativePath);
+			queue.push(relativePath);
+		}
+	}
+	let current = queue.shift();
+	while (current !== void 0) {
+		const importers = invertGraph(graph, current);
+		for (const importer of importers) if (!visited.has(importer)) {
+			visited.add(importer);
+			queue.push(importer);
+		}
+		current = queue.shift();
+	}
+	const originals = new Set(files.map((file) => relative(sourceRoot, resolve(file)).replaceAll("\\", "/")));
+	return [...visited].filter((file) => !originals.has(file)).map((file) => join(sourceRoot, file));
+}
+const ESLINT_CACHE_PATH = ".eslintcache";
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".json"
+];
+const ENTRY_CANDIDATES = [
+	"index.ts",
+	"cli.ts",
+	"main.ts"
+];
+const MAX_ERRORS = 5;
+const SETTINGS_FILE = ".claude/sentinel.local.md";
+const DEFAULT_CACHE_BUST = ["*.config.*", "**/tsconfig*.json"];
+const DEFAULT_MAX_LINT_ATTEMPTS = 1;
+const DEFAULT_MAX_STOP_ATTEMPTS = 1;
+const DEFAULT_SETTINGS = {
+	cacheBust: [...DEFAULT_CACHE_BUST],
+	eslint: true,
+	lint: true,
+	maxLintAttempts: DEFAULT_MAX_LINT_ATTEMPTS,
+	oxlint: false,
+	runner: "pnpm exec",
+	typecheck: true,
+	typecheckArgs: []
+};
+function readSettings() {
+	if (!existsSync(SETTINGS_FILE)) return { ...DEFAULT_SETTINGS };
+	const fields = parseFrontmatter(readFileSync(SETTINGS_FILE, "utf-8"));
+	const cacheBustRaw = fields.get("cache-bust") ?? "";
+	const userPatterns = cacheBustRaw ? cacheBustRaw.split(",").map((entry) => entry.trim()).filter(Boolean) : [];
+	const maxAttemptsRaw = fields.get("max-lint-attempts");
+	const maxLintAttempts = maxAttemptsRaw !== void 0 ? Number(maxAttemptsRaw) : DEFAULT_MAX_LINT_ATTEMPTS;
+	return {
+		cacheBust: [...DEFAULT_CACHE_BUST, ...userPatterns],
+		eslint: fields.get("eslint") !== "false",
+		lint: fields.get("lint") !== "false",
+		maxLintAttempts,
+		oxlint: fields.get("oxlint") === "true",
+		runner: fields.get("runner") ?? DEFAULT_SETTINGS.runner,
+		typecheck: fields.get("typecheck") !== "false",
+		typecheckArgs: (fields.get("typecheck-args") ?? "").split(",").map((entry) => entry.trim()).filter(Boolean)
+	};
+}
+function getChangedFiles() {
+	const options = {
+		encoding: "utf-8",
+		stdio: "pipe"
+	};
+	const changed = execSync("git diff --name-only --diff-filter=d HEAD", options);
+	const untracked = execSync("git ls-files --others --exclude-standard", options);
+	return [...changed.trim().split("\n"), ...untracked.trim().split("\n")].filter(Boolean);
+}
+function isLintableFile(filePath, extensions = DEFAULT_EXTENSIONS) {
+	return extensions.some((extension) => filePath.endsWith(extension));
+}
+function findEntryPoints(sourceRoot) {
+	return ENTRY_CANDIDATES.map((name) => join(sourceRoot, name)).filter((path) => {
+		return existsSync(path);
+	});
+}
+function getDependencyGraph(sourceRoot, entryPoints, runner = DEFAULT_SETTINGS.runner) {
+	execSync("which madge", {
+		stdio: "pipe",
+		timeout: 1e3
+	});
+	const output = execSync(`${runner} madge --json ${entryPoints.map((ep) => `"${ep}"`).join(" ")}`, {
+		cwd: sourceRoot,
+		encoding: "utf-8",
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		timeout: 3e4
+	});
+	return JSON.parse(output);
+}
+function invertGraph(graph, target) {
+	const importers = [];
+	for (const [file, dependencies] of Object.entries(graph)) if (dependencies.includes(target)) importers.push(file);
+	return importers;
+}
+function findSourceRoot(filePath) {
+	let current = dirname(filePath);
+	while (current !== dirname(current)) {
+		if (existsSync(join(current, "package.json"))) {
+			const sourceDirectory = join(current, "src");
+			if (existsSync(sourceDirectory)) return sourceDirectory;
+			return current;
+		}
+		current = dirname(current);
+	}
+}
+function readLintAttempts() {
+	if (!existsSync(LINT_STATE_PATH)) return {};
+	try {
+		return JSON.parse(readFileSync(LINT_STATE_PATH, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+function writeLintAttempts(attempts) {
+	mkdirSync(dirname(LINT_STATE_PATH), { recursive: true });
+	writeFileSync(LINT_STATE_PATH, JSON.stringify(attempts));
+}
+function readStopAttempts() {
+	if (!existsSync(STOP_STATE_PATH)) return 0;
+	try {
+		return JSON.parse(readFileSync(STOP_STATE_PATH, "utf-8"));
+	} catch {
+		return 0;
+	}
+}
+function writeStopAttempts(count) {
+	mkdirSync(dirname(STOP_STATE_PATH), { recursive: true });
+	writeFileSync(STOP_STATE_PATH, JSON.stringify(count));
+}
+function stopDecision(input) {
+	if (input.errorFiles.length === 0) {
+		if (input.stopAttempts > 0) return { resetStopAttempts: true };
+		return;
+	}
+	if (input.errorFiles.every((file) => {
+		return findAttempts(file, input.lintAttempts) >= input.maxLintAttempts;
+	})) return;
+	if (input.stopAttempts >= DEFAULT_MAX_STOP_ATTEMPTS) return { reason: `Unresolved lint errors in: ${input.errorFiles.join(", ")}. These may be pre-existing.` };
+	return {
+		decision: "block",
+		reason: `Lint errors detected in: ${input.errorFiles.join(", ")}. If related to your changes, please fix before finishing.`
+	};
+}
+function clearStopAttempts() {
+	if (existsSync(STOP_STATE_PATH)) unlinkSync(STOP_STATE_PATH);
+}
+function clearLintAttempts() {
+	if (existsSync(LINT_STATE_PATH)) unlinkSync(LINT_STATE_PATH);
+}
+function resolveBustFiles(patterns) {
+	const positive = patterns.filter((pattern) => !pattern.startsWith("!"));
+	const negative = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+	const matched = positive.flatMap((pattern) => globSync(pattern));
+	if (negative.length === 0) return matched;
+	const excluded = new Set(negative.flatMap((pattern) => globSync(pattern)));
+	return matched.filter((file) => !excluded.has(file));
+}
+function shouldBustCache(patterns) {
+	if (patterns.length === 0) return false;
+	if (!existsSync(ESLINT_CACHE_PATH)) return false;
+	const files = resolveBustFiles(patterns);
+	if (files.length === 0) return false;
+	const cacheMtime = statSync(ESLINT_CACHE_PATH).mtimeMs;
+	return files.some((file) => statSync(file).mtimeMs > cacheMtime);
+}
+function clearCache() {
+	if (existsSync(ESLINT_CACHE_PATH)) unlinkSync(ESLINT_CACHE_PATH);
+}
+function invalidateCacheEntries(filePaths) {
+	if (filePaths.length === 0) return;
+	if (!existsSync(ESLINT_CACHE_PATH)) return;
+	const cache = createFromFile(ESLINT_CACHE_PATH);
+	for (const file of filePaths) cache.removeEntry(file);
+	cache.reconcile();
+}
+function runOxlint(filePath, extraFlags = [], runner = DEFAULT_SETTINGS.runner) {
+	const flags = extraFlags.length > 0 ? `${extraFlags.join(" ")} ` : "";
+	try {
+		execSync(`${runner} oxlint ${flags}"${filePath}"`, { stdio: "pipe" });
+		return;
+	} catch (err_) {
+		const err = err_;
+		const stdout = err.stdout?.toString() ?? "";
+		const stderr = err.stderr?.toString() ?? "";
+		const message = err.message ?? "";
+		return stdout || stderr || message;
+	}
+}
+function runEslint(filePath, extraFlags = [], runner = DEFAULT_SETTINGS.runner) {
+	const flags = ["--cache", ...extraFlags].join(" ");
+	try {
+		execSync(`${runner} eslint_d ${flags} "${filePath}"`, {
+			env: {
+				...process.env,
+				ESLINT_IN_EDITOR: "true"
+			},
+			stdio: "pipe"
+		});
+		return;
+	} catch (err_) {
+		const err = err_;
+		const stdout = err.stdout?.toString() ?? "";
+		const stderr = err.stderr?.toString() ?? "";
+		const message = err.message ?? "";
+		return stdout || stderr || message;
+	}
+}
+function restartDaemon(runner = DEFAULT_SETTINGS.runner) {
+	const [command = "pnpm", ...prefixArgs] = runner.split(/\s+/);
+	const child = spawn(command, [
+		...prefixArgs,
+		"eslint_d",
+		"restart"
+	], {
+		detached: true,
+		env: {
+			...process.env,
+			ESLINT_IN_EDITOR: "true"
+		},
+		stdio: "pipe"
+	});
+	child.stderr.on("data", (data) => {
+		process.stderr.write(`[eslint_d restart] ${data.toString()}`);
+	});
+	child.on("error", (error) => {
+		process.stderr.write(`[eslint_d restart] failed: ${error.message}\n`);
+	});
+	child.unref();
+}
+function formatErrors(output) {
+	return output.split("\n").filter((line) => /error/i.test(line)).slice(0, MAX_ERRORS);
+}
+function buildHookOutput(filePath, errors) {
+	const errorText = errors.join("\n");
+	const isTruncated = errors.length >= MAX_ERRORS;
+	const userMessage = `⚠️ Lint errors in ${filePath}:\n${errorText}${isTruncated ? "\n..." : ""}`;
+	return {
+		decision: void 0,
+		hookSpecificOutput: {
+			additionalContext: `⚠️ Lint errors in ${filePath}:\n${errorText}${isTruncated ? "\n(run lint to view more)" : ""}`,
+			hookEventName: "PostToolUse"
+		},
+		systemMessage: userMessage
+	};
+}
+function lint(filePath, extraFlags = [], settings = DEFAULT_SETTINGS) {
+	if (shouldBustCache(settings.cacheBust)) clearCache();
+	else invalidateCacheEntries(findImporters(filePath, settings.runner));
+	const outputs = [];
+	if (settings.oxlint) {
+		const output = runOxlint(filePath, extraFlags, settings.runner);
+		if (output !== void 0) outputs.push(output);
+	}
+	if (settings.eslint) {
+		const output = runEslint(filePath, extraFlags, settings.runner);
+		if (output !== void 0) outputs.push(output);
+	}
+	if (settings.eslint) restartDaemon(settings.runner);
+	if (outputs.length > 0) {
+		const errors = formatErrors(outputs.join("\n"));
+		if (errors.length > 0) return buildHookOutput(filePath, errors);
+	}
+}
+function main(targets, settings = DEFAULT_SETTINGS) {
+	if (shouldBustCache(settings.cacheBust)) clearCache();
+	else invalidateCacheEntries(getChangedFiles());
+	let hasErrors = false;
+	for (const target of targets) {
+		const outputs = [];
+		if (settings.oxlint) {
+			const output = runOxlint(target, ["--color"], settings.runner);
+			if (output !== void 0) outputs.push(output);
+		}
+		if (settings.eslint) {
+			const output = runEslint(target, ["--color"], settings.runner);
+			if (output !== void 0) outputs.push(output);
+		}
+		for (const output of outputs) {
+			hasErrors = true;
+			const filtered = output.split("\n").filter((line) => !line.startsWith("[")).join("\n").trim();
+			if (filtered.length > 0) process.stderr.write(`${filtered}\n`);
+		}
+	}
+	if (settings.eslint) restartDaemon(settings.runner);
+	if (hasErrors) process.exit(1);
+}
+function parseFrontmatter(content) {
+	const fields = /* @__PURE__ */ new Map();
+	const frontmatter = /^---\n([\s\S]*?)\n---/m.exec(content)?.[1];
+	if (frontmatter === void 0) return fields;
+	for (const line of frontmatter.split("\n")) {
+		const colon = line.indexOf(":");
+		if (colon > 0) {
+			const key = line.slice(0, colon).trim();
+			const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+			fields.set(key, value);
+		}
+	}
+	return fields;
+}
+function endsWithSegment(haystack, needle) {
+	if (haystack === needle) return true;
+	if (!needle.includes("/")) return false;
+	return haystack.endsWith(`/${needle}`);
+}
+function findAttempts(file, lintAttempts) {
+	if (file in lintAttempts) return lintAttempts[file];
+	const normalized = file.replaceAll("\\", "/");
+	for (const [key, count] of Object.entries(lintAttempts)) {
+		const normalizedKey = key.replaceAll("\\", "/");
+		if (endsWithSegment(normalizedKey, normalized) || endsWithSegment(normalized, normalizedKey)) return count;
+	}
+	return 0;
+}
+function findImporters(filePath, runner = DEFAULT_SETTINGS.runner) {
+	const absPath = resolve(filePath);
+	const sourceRoot = findSourceRoot(absPath);
+	if (sourceRoot === void 0) return [];
+	const entryPoints = findEntryPoints(sourceRoot);
+	if (entryPoints.length === 0) return [];
+	return invertGraph(getDependencyGraph(sourceRoot, entryPoints, runner), relative(sourceRoot, absPath).replaceAll("\\", "/")).map((file) => join(sourceRoot, file));
+}
+if (process.argv[1]?.endsWith("scripts/lint.ts") === true) {
+	const settings = readSettings();
+	main(process.argv.length > 2 ? process.argv.slice(2) : ["."], settings);
+}
+
+//#endregion
+export { DEFAULT_CACHE_BUST, buildHookOutput, clearCache, clearEditedFiles, clearLintAttempts, clearStopAttempts, findEntryPoints, findSourceRoot, formatErrors, getChangedFiles, getDependencyGraph, getTransitiveDependents, invalidateCacheEntries, invertGraph, isLintableFile, isProtectedFile, lint, main, readEditedFiles, readLintAttempts, readSettings, readStopAttempts, resolveBustFiles, restartDaemon, runEslint, runOxlint, shouldBustCache, stopDecision, writeEditedFile, writeLintAttempts, writeStopAttempts };

package/dist/scripts/type-check.d.mts

@@ -0,0 +1,49 @@
+import { t as PostToolUseHookOutput } from "../events.mjs";
+
+//#region scripts/type-check.d.ts
+interface TsconfigCache {
+  hashes: Record<string, string>;
+  mappings: Record<string, string>;
+  projectRoot: string;
+}
+declare function readTsconfigCache(projectRoot: string): TsconfigCache | undefined;
+declare function writeTsconfigCache(projectRoot: string, cache: TsconfigCache): void;
+declare function resolveTsconfig(filePath: string, projectRoot: string): string | undefined;
+declare function isTypeCheckable(filePath: string): boolean;
+declare function resolveViaReferences(directory: string, configPath: string, targetFile: string): string | undefined;
+declare function findTsconfigForFile(targetFile: string, projectRoot: string): string | undefined;
+declare function runTypeCheck(tsconfig: string, runner?: string, extraArgs?: Array<string>): string | undefined;
+interface TypeCheckSettings {
+  runner: string;
+  typecheck: boolean;
+  typecheckArgs?: Array<string>;
+}
+interface TypecheckStopDecisionResult {
+  decision?: "block";
+  reason?: string;
+  resetStopAttempts?: true;
+}
+interface TypeCheckOutputOptions {
+  dependencyErrors: Array<string>;
+  fileErrors: Array<string>;
+  totalDependencyErrors: number;
+  totalFileErrors: number;
+}
+interface TypecheckStopDecisionInput {
+  errorFiles: Array<string>;
+  lintAttempts: Record<string, number>;
+  maxLintAttempts: number;
+  stopAttempts: number;
+}
+declare function partitionErrors(errors: Array<string>, filePath: string, projectRoot: string): {
+  dependencyErrors: Array<string>;
+  fileErrors: Array<string>;
+};
+declare function buildTypeCheckOutput(options: TypeCheckOutputOptions): PostToolUseHookOutput;
+declare function typeCheck(filePath: string, settings: TypeCheckSettings): PostToolUseHookOutput | undefined;
+declare function typecheckStopDecision(input: TypecheckStopDecisionInput): TypecheckStopDecisionResult | undefined;
+declare function readTypecheckStopAttempts(): number;
+declare function writeTypecheckStopAttempts(count: number): void;
+declare function clearTypecheckStopAttempts(): void;
+//#endregion
+export { TsconfigCache, TypeCheckSettings, TypecheckStopDecisionResult, buildTypeCheckOutput, clearTypecheckStopAttempts, findTsconfigForFile, isTypeCheckable, partitionErrors, readTsconfigCache, readTypecheckStopAttempts, resolveTsconfig, resolveViaReferences, runTypeCheck, typeCheck, typecheckStopDecision, writeTsconfigCache, writeTypecheckStopAttempts };

package/dist/scripts/type-check.mjs

@@ -0,0 +1,176 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { createFilesMatcher, parseTsconfig } from "get-tsconfig";
+import { createHash } from "node:crypto";
+
+//#region scripts/type-check.ts
+const TYPE_CHECK_EXTENSIONS = [".ts", ".tsx"];
+const CACHE_PATH = join(".claude", "state", "tsconfig-cache.json");
+const STOP_STATE_PATH = join(".claude", "state", "typecheck-stop-attempts.json");
+const DEFAULT_MAX_STOP_ATTEMPTS = 3;
+function readTsconfigCache(projectRoot) {
+	const cachePath = join(projectRoot, CACHE_PATH);
+	if (!existsSync(cachePath)) return;
+	const content = readFileSync(cachePath, "utf-8");
+	return JSON.parse(content);
+}
+function writeTsconfigCache(projectRoot, cache) {
+	mkdirSync(join(projectRoot, ".claude", "state"), { recursive: true });
+	writeFileSync(join(projectRoot, CACHE_PATH), JSON.stringify(cache));
+}
+function resolveTsconfig(filePath, projectRoot) {
+	const cache = readTsconfigCache(projectRoot);
+	if (cache?.projectRoot === projectRoot) {
+		const cachedTsconfig = cache.mappings[filePath];
+		if (cachedTsconfig !== void 0 && existsSync(cachedTsconfig)) {
+			if (hashFileContent(cachedTsconfig) === cache.hashes[cachedTsconfig]) return cachedTsconfig;
+		}
+	}
+	const tsconfig = findTsconfigForFile(filePath, projectRoot);
+	if (tsconfig !== void 0) {
+		const hash = hashFileContent(tsconfig);
+		writeTsconfigCache(projectRoot, {
+			hashes: {
+				...cache?.hashes,
+				[tsconfig]: hash
+			},
+			mappings: {
+				...cache?.mappings,
+				[filePath]: tsconfig
+			},
+			projectRoot
+		});
+	}
+	return tsconfig;
+}
+function hashFileContent(filePath) {
+	const content = readFileSync(filePath, "utf-8");
+	return createHash("sha256").update(content).digest("hex");
+}
+const DEFAULT_RUNNER = "pnpm exec";
+function isTypeCheckable(filePath) {
+	return TYPE_CHECK_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+function resolveViaReferences(directory, configPath, targetFile) {
+	const { references } = parseTsconfig(configPath);
+	if (references === void 0 || references.length === 0) return;
+	for (const ref of references) {
+		const refPath = join(directory, ref.path);
+		const refConfigPath = refPath.endsWith(".json") ? refPath : join(refPath, "tsconfig.json");
+		if (!existsSync(refConfigPath)) continue;
+		if (createFilesMatcher({
+			config: parseTsconfig(refConfigPath),
+			path: refConfigPath
+		})(targetFile) !== void 0) return refConfigPath;
+	}
+}
+function findTsconfigForFile(targetFile, projectRoot) {
+	let directory = dirname(targetFile);
+	while (directory.length >= projectRoot.length) {
+		const candidate = join(directory, "tsconfig.json");
+		if (existsSync(candidate)) return resolveViaReferences(directory, candidate, targetFile) ?? candidate;
+		const parent = dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+}
+function runTypeCheck(tsconfig, runner = DEFAULT_RUNNER, extraArgs = []) {
+	const args = [`tsgo -p "${tsconfig}" --noEmit --pretty false`, ...extraArgs].join(" ");
+	try {
+		execSync(`${runner} ${args}`, { stdio: "pipe" });
+		return;
+	} catch (err_) {
+		const err = err_;
+		const stdout = err.stdout?.toString() ?? "";
+		const stderr = err.stderr?.toString() ?? "";
+		const message = err.message ?? "";
+		return stdout || stderr || message;
+	}
+}
+const MAX_ERRORS = 5;
+function partitionErrors(errors, filePath, projectRoot) {
+	const relativePath = relative(projectRoot, filePath).replaceAll("\\", "/");
+	const fileErrors = [];
+	const dependencyErrors = [];
+	for (const error of errors) if (error.startsWith(relativePath)) fileErrors.push(error);
+	else dependencyErrors.push(error);
+	return {
+		dependencyErrors,
+		fileErrors
+	};
+}
+function buildTypeCheckOutput(options) {
+	const sections = [];
+	if (options.totalFileErrors > 0) {
+		const text = options.fileErrors.join("\n");
+		const errorSuffix = options.totalFileErrors === 1 ? "error" : "errors";
+		sections.push(`TypeScript found ${options.totalFileErrors} type ${errorSuffix} in edited file:\n${text}`);
+	}
+	if (options.totalDependencyErrors > 0) {
+		const text = options.dependencyErrors.join("\n");
+		const errorSuffix = options.totalDependencyErrors === 1 ? "error" : "errors";
+		sections.push(`TypeScript found ${options.totalDependencyErrors} type ${errorSuffix} in other files:\n${text}`);
+	}
+	const isTruncated = options.fileErrors.length < options.totalFileErrors || options.dependencyErrors.length < options.totalDependencyErrors;
+	const suffix = isTruncated ? "\n..." : "";
+	const claudeSuffix = isTruncated ? "\n(run typecheck to view more)" : "";
+	const userMessage = sections.join("\n\n") + suffix;
+	return {
+		decision: void 0,
+		hookSpecificOutput: {
+			additionalContext: sections.join("\n\n") + claudeSuffix,
+			hookEventName: "PostToolUse"
+		},
+		systemMessage: userMessage
+	};
+}
+function typeCheck(filePath, settings) {
+	if (!isTypeCheckable(filePath)) return;
+	const projectRoot = process.env["CLAUDE_PROJECT_DIR"] ?? process.cwd();
+	const tsconfig = resolveTsconfig(filePath, projectRoot);
+	if (tsconfig === void 0) return;
+	const output = runTypeCheck(tsconfig, settings.runner, settings.typecheckArgs);
+	if (output === void 0) return;
+	const allErrors = output.split("\n").filter((line) => /error TS/i.test(line));
+	if (allErrors.length === 0) return;
+	const { dependencyErrors, fileErrors } = partitionErrors(allErrors, filePath, projectRoot);
+	return buildTypeCheckOutput({
+		dependencyErrors: dependencyErrors.slice(0, MAX_ERRORS),
+		fileErrors: fileErrors.slice(0, MAX_ERRORS),
+		totalDependencyErrors: dependencyErrors.length,
+		totalFileErrors: fileErrors.length
+	});
+}
+function typecheckStopDecision(input) {
+	if (input.errorFiles.length === 0) {
+		if (input.stopAttempts > 0) return { resetStopAttempts: true };
+		return;
+	}
+	if (input.errorFiles.every((file) => {
+		return (input.lintAttempts[file] ?? 0) >= input.maxLintAttempts;
+	})) return;
+	if (input.stopAttempts >= DEFAULT_MAX_STOP_ATTEMPTS) return { reason: `Unresolved type errors in: ${input.errorFiles.join(", ")}. These may be pre-existing.` };
+	return {
+		decision: "block",
+		reason: `Type errors detected in: ${input.errorFiles.join(", ")}. If related to your changes, fix before finishing.`
+	};
+}
+function readTypecheckStopAttempts() {
+	if (!existsSync(STOP_STATE_PATH)) return 0;
+	try {
+		return JSON.parse(readFileSync(STOP_STATE_PATH, "utf-8"));
+	} catch {
+		return 0;
+	}
+}
+function writeTypecheckStopAttempts(count) {
+	mkdirSync(dirname(STOP_STATE_PATH), { recursive: true });
+	writeFileSync(STOP_STATE_PATH, JSON.stringify(count));
+}
+function clearTypecheckStopAttempts() {
+	if (existsSync(STOP_STATE_PATH)) unlinkSync(STOP_STATE_PATH);
+}
+
+//#endregion
+export { buildTypeCheckOutput, clearTypecheckStopAttempts, findTsconfigForFile, isTypeCheckable, partitionErrors, readTsconfigCache, readTypecheckStopAttempts, resolveTsconfig, resolveViaReferences, runTypeCheck, typeCheck, typecheckStopDecision, writeTsconfigCache, writeTypecheckStopAttempts };

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@isentinel/hooks",
+  "version": "1.2.0",
+  "description": "Claude Code hooks for linting and type-checking TypeScript projects",
+  "keywords": [
+    "claude",
+    "hooks",
+    "eslint",
+    "typescript",
+    "linting"
+  ],
+  "homepage": "https://github.com/christopher-buss/skills",
+  "bugs": {
+    "url": "https://github.com/christopher-buss/skills/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/christopher-buss/skills.git"
+  },
+  "license": "MIT",
+  "author": "Christopher Buss <christopher.buss@pm.me> (https://github.com/christopher-buss)",
+  "type": "module",
+  "exports": {
+    "./hooks/*": "./dist/hooks/*.mjs",
+    "./lint": {
+      "types": "./dist/scripts/lint.d.mts",
+      "default": "./dist/scripts/lint.mjs"
+    },
+    "./type-check": {
+      "types": "./dist/scripts/type-check.d.mts",
+      "default": "./dist/scripts/type-check.mjs"
+    }
+  },
+  "types": "./dist/scripts/lint.d.mts",
+  "files": [
+    "dist/"
+  ],
+  "simple-git-hooks": {
+    "pre-commit": "pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*.{ts,mts}": "eslint --fix"
+  },
+  "dependencies": {
+    "eslint_d": "^14.3.0",
+    "file-entry-cache": "^11.1.2",
+    "get-tsconfig": "^4.13.6",
+    "madge": "^8.0.0"
+  },
+  "devDependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@constellos/claude-code-kit": "^0.4.0",
+    "@isentinel/eslint-config": "5.0.0-beta.8",
+    "@isentinel/tsconfig": "^1.2.0",
+    "@types/node": "^25.0.10",
+    "@typescript/native-preview": "7.0.0-dev.20260212.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/eslint-plugin": "^1.6.9",
+    "better-typescript-lib": "^2.12.0",
+    "bumpp": "^10.4.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-pnpm": "^1.5.0",
+    "jiti": "^2.6.1",
+    "lint-staged": "^15.5.1",
+    "publint": "^0.3.18",
+    "simple-git-hooks": "^2.11.1",
+    "tsdown": "^0.20.3",
+    "type-fest": "^5.4.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "@typescript/native-preview": ">=7"
+  },
+  "peerDependenciesMeta": {
+    "@typescript/native-preview": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint --cache",
+    "pack": "pnpm pack",
+    "release": "bumpp",
+    "start": "node scripts/cli.ts",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsgo --noEmit"
+  }
+}