claude-toolkit 0.1.9

package/docs/stacks/solidjs-patterns.md

@@ -0,0 +1,110 @@
+# SolidJS Patterns
+
+> SolidJS reactivity, signals, effects, and component patterns.
+
+**Type:** Stack Skill (requires `solidjs` stack)
+**Source:** [`stacks/solidjs/skills/solidjs-patterns/SKILL.md`](../stacks/solidjs/skills/solidjs-patterns/SKILL.md)
+**Directory Mappings:** `src/components/`, `src/hooks/`, `src/pages/`
+**File Extensions:** `.tsx`, `.jsx`
+
+## Overview
+
+SolidJS uses **fine-grained reactivity** with no virtual DOM. Components run once; only the reactive expressions inside them re-execute when dependencies change. This is fundamentally different from React.
+
+## Core Primitives
+
+### createSignal
+```tsx
+const [count, setCount] = createSignal(0);
+// Read: count() -- always call as function
+// Write: setCount(1) or setCount(prev => prev + 1)
+```
+
+### createEffect
+Runs side effects when tracked dependencies change. Automatically tracks any signal read inside it.
+```tsx
+createEffect(() => {
+  console.log("Count changed:", count());
+});
+```
+
+### createMemo
+Derived computation that caches its result. Only recalculates when dependencies change.
+```tsx
+const doubled = createMemo(() => count() * 2);
+```
+
+### createResource
+Async data fetching tied to a signal source. Returns a resource with loading/error states.
+```tsx
+const [data] = createResource(userId, fetchUser);
+// data(), data.loading, data.error
+```
+
+## Component Patterns
+
+| Component | Purpose | Example |
+|---|---|---|
+| `<Show>` | Conditional rendering | `<Show when={isLoggedIn()} fallback={<Login />}>` |
+| `<For>` | List rendering (keyed by reference) | `<For each={items()}>{(item) => ...}</For>` |
+| `<Switch>/<Match>` | Multi-branch conditional | `<Match when={state() === "loading"}>` |
+| `<ErrorBoundary>` | Error catching | `<ErrorBoundary fallback={(err) => ...}>` |
+| `<Suspense>` | Async loading states | `<Suspense fallback={<Loading />}>` |
+
+## Props Handling
+
+**CRITICAL: Never destructure props.** Destructuring breaks reactivity.
+
+```tsx
+// WRONG -- kills reactivity
+const MyComponent = ({ name, count }) => { ... };
+
+// CORRECT -- preserves reactivity
+const MyComponent = (props) => {
+  return <div>{props.name}: {props.count}</div>;
+};
+```
+
+- Use `mergeProps` for defaults: `const merged = mergeProps({ color: "blue" }, props)`
+- Use `splitProps` to separate prop groups: `const [local, others] = splitProps(props, ["class", "style"])`
+
+## Store Patterns
+
+`createStore` provides deep reactivity for complex nested state with path-based updates:
+
+```tsx
+const [state, setState] = createStore({
+  user: { name: "Alice", settings: { theme: "dark" } }
+});
+
+// Granular updates
+setState("user", "settings", "theme", "light");
+```
+
+## Anti-patterns
+
+| Anti-pattern | Why it's wrong |
+|---|---|
+| **Destructuring props** | Breaks reactivity. Always use `props.x`. |
+| **Unnecessary createEffect** | If you just need a derived value, use `createMemo`. |
+| **Treating it like React** | Components do NOT re-run. Only reactive expressions update. |
+| **Array index as key in For** | `<For>` is keyed by reference automatically. |
+| **Reading signals outside reactive context** | Captures the value once at component top level. |
+| **Forgetting to call signals** | `count` is a getter function, `count()` is the value. |
+
+## Best Practices Reference
+
+For deeper guidance on SolidJS patterns (sourced from official docs and Ryan Carniato):
+
+| Topic | Guide |
+|---|---|
+| How fine-grained reactivity works internally | [Reactivity Model](../best-practices/solidjs/reactivity-model.md) |
+| Signal vs memo, derived values, when to use what | [Signals & State](../best-practices/solidjs/signals-and-state.md) |
+| `produce`, `reconcile`, path syntax for nested state | [Stores & Nested State](../best-practices/solidjs/stores-and-nested-state.md) |
+| `mergeProps`, `splitProps`, `children` helper | [Props Patterns](../best-practices/solidjs/props-patterns.md) |
+| When NOT to use effects, `onMount`, `onCleanup` | [Effects & Lifecycle](../best-practices/solidjs/effects-and-lifecycle.md) |
+| `Show`, `For`, `Switch`/`Match`, `Suspense` details | [Control Flow](../best-practices/solidjs/control-flow.md) |
+| `createResource`, `createAsync`, optimistic updates | [Data Fetching](../best-practices/solidjs/data-fetching.md) |
+| Full catalog of common SolidJS mistakes | [Anti-Patterns](../best-practices/solidjs/anti-patterns.md) |
+
+See the full collection: [SolidJS Best Practices](../best-practices/solidjs/README.md)

package/docs/stacks/vanilla-extract-patterns.md

@@ -0,0 +1,115 @@
+# Vanilla Extract Patterns
+
+> Type-safe CSS with vanilla-extract, sprinkles, and recipes.
+
+**Type:** Stack Skill (requires `vanilla-extract` stack)
+**Source:** [`stacks/vanilla-extract/skills/vanilla-extract-patterns/SKILL.md`](../stacks/vanilla-extract/skills/vanilla-extract-patterns/SKILL.md)
+**Directory Mappings:** `src/styles/`, `src/theme/`
+**File Extensions:** `.css.ts`
+
+## Overview
+
+vanilla-extract provides zero-runtime, type-safe CSS written in TypeScript. All styles are authored in `*.css.ts` files and extracted to static CSS at build time.
+
+**Important:** All vanilla-extract files MUST use the `*.css.ts` extension. The build plugin only processes these files.
+
+## Core API
+
+### style() -- Single Class Styles
+
+Creates a single scoped class name with type-checked CSS properties.
+
+```ts
+import { style } from '@vanilla-extract/css';
+
+export const button = style({
+  padding: '8px 16px',
+  borderRadius: '4px',
+  ':hover': { opacity: 0.9 },
+});
+```
+
+Compose styles by passing an array:
+
+```ts
+export const primaryButton = style([button, { background: 'blue', color: 'white' }]);
+```
+
+### styleVariants() -- Variant Maps
+
+Creates a map of related style variants from a single definition.
+
+```ts
+export const colorVariant = styleVariants({
+  primary: { background: 'blue', color: 'white' },
+  secondary: { background: 'gray', color: 'black' },
+  danger: { background: 'red', color: 'white' },
+});
+```
+
+### recipe() -- Component Variants
+
+Creates multi-variant styles with `defaultVariants` and compound variants. Requires `@vanilla-extract/recipes`.
+
+```ts
+export const buttonRecipe = recipe({
+  base: { padding: '8px 16px', borderRadius: '4px' },
+  variants: {
+    color: {
+      primary: { background: 'blue', color: 'white' },
+      secondary: { background: 'gray', color: 'black' },
+    },
+    size: {
+      small: { fontSize: '12px' },
+      medium: { fontSize: '14px' },
+      large: { fontSize: '16px' },
+    },
+  },
+  defaultVariants: { color: 'primary', size: 'medium' },
+});
+```
+
+### globalStyle() -- Use Sparingly
+
+For CSS resets, body defaults, or third-party element overrides only.
+
+## Theming
+
+### Contract-first theming (recommended)
+
+```ts
+import { createThemeContract, createTheme } from '@vanilla-extract/css';
+
+export const vars = createThemeContract({
+  color: { brand: null, text: null, background: null },
+  space: { small: null, medium: null, large: null },
+});
+
+export const lightTheme = createTheme(vars, {
+  color: { brand: '#0066ff', text: '#1a1a1a', background: '#ffffff' },
+  space: { small: '4px', medium: '8px', large: '16px' },
+});
+```
+
+Use `vars` for type-safe token references: `style({ color: vars.color.brand })`
+
+### Sprinkles -- Atomic Utility Classes
+
+Requires `@vanilla-extract/sprinkles`. Creates constrained atomic CSS classes with responsive conditions.
+
+## Anti-patterns
+
+| Anti-pattern                  | Why it's wrong                                                   |
+| ----------------------------- | ---------------------------------------------------------------- |
+| **Inline styles**             | Defeats the purpose. Use `style()` or `sprinkles()`.             |
+| **Runtime CSS**               | vanilla-extract is build-time only.                              |
+| **Overusing globalStyle**     | Prefer scoped `style()`. Global styles create implicit coupling. |
+| **Non-`.css.ts` files**       | Style definitions in `.ts` files will not be processed.          |
+| **String-based theme values** | Use the `vars` object for type-safe references.                  |
+
+## Best Practices Reference
+
+| Topic                                     | Guide                                                                        |
+| ----------------------------------------- | ---------------------------------------------------------------------------- |
+| `type` vs `interface` for theme contracts | [Type vs Interface](../best-practices/typescript/type-vs-interface.md)       |
+| `satisfies` for config validation         | [The satisfies Operator](../best-practices/typescript/satisfies-operator.md) |

package/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "claude-toolkit",
+	"version": "0.1.9",
+	"description": "Reusable Claude Code configuration toolkit with stack-specific connectors",
+	"type": "module",
+	"bin": {
+		"claude-toolkit": "./bin/cli.ts"
+	},
+	"exports": {
+		".": {
+			"import": "./src/index.ts",
+			"types": "./src/index.ts"
+		}
+	},
+	"files": [
+		"bin/",
+		"src/",
+		"core/",
+		"stacks/",
+		"templates/",
+		"docs/",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check --write",
+		"lint:check": "biome check",
+		"prepare": "npx husky"
+	},
+	"lint-staged": {
+		"*.{ts,tsx,js,jsx,json,css}": "biome check --write --no-errors-on-unmatched"
+	},
+	"keywords": [
+		"claude",
+		"claude-code",
+		"ai",
+		"developer-tools",
+		"configuration",
+		"toolkit"
+	],
+	"author": "william-queant",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/william-queant/claude-toolkit.git"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.10",
+		"@types/bun": "latest",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.4.0",
+		"typescript": "^5.8.0"
+	},
+	"engines": {
+		"bun": ">=1.0.0"
+	},
+	"module": "src/index.ts"
+}

package/src/generator.ts

@@ -0,0 +1,317 @@
+import { copyFile as fsCopyFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import type { ClaudeToolkitConfig, ResolvedConfig, StackPack } from "./types.js";
+import { copyDir, exists, readJson, writeFileEnsureDir } from "./utils.js";
+
+const TOOLKIT_ROOT = resolve(import.meta.dirname, "..");
+
+/** Resolve the full configuration by merging core + stacks + project config */
+async function resolveConfig(config: ClaudeToolkitConfig): Promise<ResolvedConfig> {
+	const stacks: StackPack[] = [];
+	const allMappings: Record<string, string> = {};
+
+	// Load stack packs
+	for (const stackName of config.stacks) {
+		const stackDir = join(TOOLKIT_ROOT, "stacks", stackName);
+		const stackJsonPath = join(stackDir, "stack.json");
+		if (exists(stackJsonPath)) {
+			const pack = await readJson<StackPack>(stackJsonPath);
+			stacks.push(pack);
+			Object.assign(allMappings, pack.defaultMappings);
+		}
+	}
+
+	// Project mappings override stack defaults
+	if (config.directoryMappings) {
+		Object.assign(allMappings, config.directoryMappings);
+	}
+
+	// Resolve hooks with package manager defaults
+	const installCmd =
+		config.hooks?.installCommand ??
+		(config.packageManager === "bun" ? "bun install" : `${config.packageManager} install`);
+
+	const hooks = {
+		...config.hooks,
+		installCommand: installCmd,
+	};
+
+	// Collect skill names
+	const skills = [
+		"ct-systematic-debugging",
+		"ct-testing-patterns",
+		"ct-typescript-conventions",
+		"ct-verification-before-completion",
+		...(config.excludeSkills ? [] : []),
+	].filter((s) => !config.excludeSkills?.includes(s));
+
+	return { config, skills, directoryMappings: allMappings, hooks, stacks };
+}
+
+/** Generate the .claude/ directory from resolved config */
+export async function generate(projectDir: string, config: ClaudeToolkitConfig): Promise<void> {
+	const resolved = await resolveConfig(config);
+	const claudeDir = join(projectDir, ".claude");
+
+	// 1. Copy core hooks
+	await copyDir(join(TOOLKIT_ROOT, "core", "hooks"), join(claudeDir, "hooks"));
+
+	// 2. Copy core skills
+	await copyDir(join(TOOLKIT_ROOT, "core", "skills"), join(claudeDir, "skills"));
+
+	// 3. Copy core commands (namespaced under ct/)
+	await copyDir(join(TOOLKIT_ROOT, "core", "commands", "ct"), join(claudeDir, "commands", "ct"));
+
+	// 4. Copy core agents
+	await copyDir(join(TOOLKIT_ROOT, "core", "agents"), join(claudeDir, "agents"));
+
+	// 5. Copy stack-specific skills
+	for (const stackName of config.stacks) {
+		const stackSkillsDir = join(TOOLKIT_ROOT, "stacks", stackName, "skills");
+		if (exists(stackSkillsDir)) {
+			await copyDir(stackSkillsDir, join(claudeDir, "skills"));
+		}
+	}
+
+	// 6. Generate skill-rules.json
+	await generateSkillRules(claudeDir, resolved);
+
+	// 7. Generate settings.json
+	await generateSettings(claudeDir, resolved);
+
+	// 8. Generate .claude/.gitignore
+	await writeFileEnsureDir(
+		join(claudeDir, ".gitignore"),
+		[
+			"# User-specific configuration",
+			"user-team-info.json",
+			"",
+			"# Local settings (personal overrides)",
+			"settings.local.json",
+			"",
+			"# Task-specific context",
+			"tasks/",
+			"",
+		].join("\n"),
+	);
+
+	// 9. Scaffold base configs
+	await scaffoldConfigs(projectDir, resolved);
+
+	// 10. Generate skills README
+	await generateSkillsReadme(claudeDir, resolved);
+
+	console.log(
+		`Generated .claude/ with ${resolved.stacks.length} stack(s) and ${resolved.skills.length} core skills`,
+	);
+}
+
+/** Generate skill-rules.json from resolved config */
+async function generateSkillRules(claudeDir: string, resolved: ResolvedConfig): Promise<void> {
+	// Load all SKILL.md files to build the rules
+	const rules: Record<string, unknown> = {};
+
+	// Load skill rules from each stack's stack.json
+	for (const stackName of resolved.config.stacks) {
+		const stackJsonPath = join(TOOLKIT_ROOT, "stacks", stackName, "stack.json");
+		if (exists(stackJsonPath)) {
+			const pack = await readJson<StackPack & { skillRules?: Record<string, unknown> }>(
+				stackJsonPath,
+			);
+			if (pack.skillRules) {
+				Object.assign(rules, pack.skillRules);
+			}
+		}
+	}
+
+	// Load core skill rules template
+	const coreRulesPath = join(TOOLKIT_ROOT, "templates", "skill-rules.base.json");
+	const baseRules = exists(coreRulesPath)
+		? await readJson<Record<string, unknown>>(coreRulesPath)
+		: {};
+
+	const skillRules = {
+		$schema: "./skill-rules.schema.json",
+		version: "2.0",
+		config: {
+			minConfidenceScore: 3,
+			showMatchReasons: true,
+			maxSkillsToShow: 5,
+		},
+		scoring: {
+			keyword: 2,
+			keywordPattern: 3,
+			pathPattern: 4,
+			directoryMatch: 5,
+			intentPattern: 4,
+			contentPattern: 3,
+			contextPattern: 2,
+		},
+		directoryMappings: resolved.directoryMappings,
+		skills: {
+			...(((baseRules as Record<string, unknown>).skills as Record<string, unknown>) ?? {}),
+			...rules,
+		},
+	};
+
+	await writeFileEnsureDir(
+		join(claudeDir, "hooks", "skill-rules.json"),
+		`${JSON.stringify(skillRules, null, 2)}\n`,
+	);
+}
+
+/** Generate settings.json with hooks */
+async function generateSettings(claudeDir: string, resolved: ResolvedConfig): Promise<void> {
+	const { hooks, config } = resolved;
+	const protectedBranches = config.git?.protectedBranches ?? ["main"];
+
+	const branchCheck = protectedBranches
+		.map((b) => `"$(git branch --show-current)" != "${b}"`)
+		.join(" && ");
+
+	const postToolUseHooks: unknown[] = [];
+
+	// Auto-format
+	if (hooks.formatter) {
+		const extensions = ["js", "jsx", "ts", "tsx"];
+		// Add stack-specific extensions
+		for (const stack of resolved.stacks) {
+			for (const ext of stack.fileExtensions) {
+				if (!extensions.includes(ext)) extensions.push(ext);
+			}
+		}
+		const extPattern = extensions.join("|");
+
+		postToolUseHooks.push({
+			type: "command",
+			command: `# Auto-format files\nif [[ "$CLAUDE_TOOL_INPUT_FILE_PATH" =~ \\.(${extPattern})$ ]]; then\n  file_path="$CLAUDE_TOOL_INPUT_FILE_PATH"\n  ${hooks.formatter} "$file_path" 2>&1\n  exit_code=$?\n  if [ $exit_code -ne 0 ]; then\n    echo '{"feedback": "Formatting failed. Check file for syntax errors."}' >&2\n    exit 1\n  else\n    echo '{"feedback": "Formatting applied.", "suppressOutput": true}'\n  fi\nfi`,
+			timeout: 30,
+		});
+	}
+
+	// Auto-install
+	const installCmd = hooks.installCommand ?? `${config.packageManager} install`;
+	postToolUseHooks.push({
+		type: "command",
+		command: `# Auto-install dependencies when package.json changes\nif [[ "$CLAUDE_TOOL_INPUT_FILE_PATH" =~ package\\.json$ ]]; then\n  echo '{"feedback": "Installing dependencies..."}' >&2\n  ${installCmd} >/dev/null 2>&1 && echo '{"feedback": "Dependencies installed.", "suppressOutput": true}' || {\n    echo '{"feedback": "Failed to install dependencies."}' >&2\n    exit 1\n  }\nfi`,
+		timeout: 60,
+	});
+
+	// Auto-run tests
+	if (hooks.testRunner) {
+		postToolUseHooks.push({
+			type: "command",
+			command: `# Auto-run tests when test files change\nif [[ "$CLAUDE_TOOL_INPUT_FILE_PATH" =~ \\.test\\.(js|jsx|ts|tsx)$ ]] || [[ "$CLAUDE_TOOL_INPUT_FILE_PATH" =~ \\.spec\\.(js|jsx|ts|tsx)$ ]]; then\n  echo '{"feedback": "Running tests..."}' >&2\n  ${hooks.testRunner} "$CLAUDE_TOOL_INPUT_FILE_PATH" 2>&1 | tail -30\n  exit_code=\${PIPESTATUS[0]}\n  if [ $exit_code -eq 0 ]; then\n    echo '{"feedback": "Tests passed."}'\n  else\n    echo '{"feedback": "Tests failed. See output above."}' >&2\n  fi\nfi`,
+			timeout: 90,
+		});
+	}
+
+	// Type-check
+	if (hooks.typeCheck) {
+		postToolUseHooks.push({
+			type: "command",
+			command: `# Type-check TypeScript files\nif [[ "$CLAUDE_TOOL_INPUT_FILE_PATH" =~ \\.(ts|tsx)$ ]]; then\n  echo '{"feedback": "Checking TypeScript types..."}' >&2\n  output=$(${hooks.typeCheck} 2>&1)\n  exit_code=$?\n  if [ $exit_code -eq 0 ]; then\n    echo '{"feedback": "No TypeScript errors.", "suppressOutput": true}'\n  else\n    errors=$(echo "$output" | grep -A 2 "error TS" | head -30)\n    if [ -n "$errors" ]; then\n      echo '{"feedback": "TypeScript found type errors:"}' >&2\n      echo "$errors" >&2\n    fi\n  fi\n  exit 0\nfi`,
+			timeout: 30,
+		});
+	}
+
+	// Extra checks (e.g., cargo check for Rust)
+	if (hooks.extraChecks) {
+		for (const check of hooks.extraChecks) {
+			postToolUseHooks.push({
+				type: "command",
+				command: `# Extra check: ${check}\nif [[ "$CLAUDE_TOOL_INPUT_FILE_PATH" =~ \\.rs$ ]]; then\n  echo '{"feedback": "Running extra check..."}' >&2\n  output=$(${check} 2>&1)\n  exit_code=$?\n  if [ $exit_code -eq 0 ]; then\n    echo '{"feedback": "Check passed.", "suppressOutput": true}'\n  else\n    echo '{"feedback": "Check failed:"}' >&2\n    echo "$output" | tail -20 >&2\n  fi\n  exit 0\nfi`,
+				timeout: 60,
+			});
+		}
+	}
+
+	const settings = {
+		includeCoAuthoredBy: true,
+		env: {
+			INSIDE_CLAUDE_CODE: "1",
+			BASH_DEFAULT_TIMEOUT_MS: "420000",
+			BASH_MAX_TIMEOUT_MS: "420000",
+		},
+		hooks: {
+			UserPromptSubmit: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/skill-eval.sh',
+							timeout: 5,
+						},
+					],
+				},
+			],
+			PreToolUse: [
+				{
+					matcher: "Edit|MultiEdit|Write",
+					hooks: [
+						{
+							type: "command",
+							command: `# Prevent editing on protected branches\n[ ${branchCheck} ] || { echo '{"block": true, "message": "Cannot edit files on a protected branch. Create a feature branch first."}' >&2; exit 2; }`,
+							timeout: 5,
+						},
+					],
+				},
+			],
+			PostToolUse: postToolUseHooks.map((hook) => ({
+				matcher: "Edit|MultiEdit|Write",
+				hooks: [hook],
+			})),
+		},
+	};
+
+	await writeFileEnsureDir(
+		join(claudeDir, "settings.json"),
+		`${JSON.stringify(settings, null, 2)}\n`,
+	);
+}
+
+/** Scaffold base config files (biome.json, tsconfig.json) into the project */
+async function scaffoldConfigs(projectDir: string, resolved: ResolvedConfig): Promise<void> {
+	if (resolved.config.scaffoldConfigs === false) return;
+
+	const configsDir = join(TOOLKIT_ROOT, "templates", "configs");
+	const configs = [
+		{ src: "biome.base.json", dest: "biome.json" },
+		{ src: "tsconfig.base.json", dest: "tsconfig.json" },
+	];
+
+	for (const { src, dest } of configs) {
+		const destPath = join(projectDir, dest);
+		if (exists(destPath)) {
+			console.log(`  Skipped ${dest} (already exists)`);
+		} else {
+			await fsCopyFile(join(configsDir, src), destPath);
+			console.log(`  Scaffolded ${dest}`);
+		}
+	}
+}
+
+/** Generate skills/README.md */
+async function generateSkillsReadme(claudeDir: string, resolved: ResolvedConfig): Promise<void> {
+	let content = "# Claude Code Skills\n\n";
+	content += "Auto-generated by claude-toolkit. Do not edit manually.\n\n";
+	content += "## Core Skills\n\n";
+	content += "| Skill | Description |\n";
+	content += "|-------|-------------|\n";
+	content +=
+		"| ct-systematic-debugging | Four-phase debugging methodology, root cause analysis |\n";
+	content += "| ct-testing-patterns | Test-driven development workflow and patterns |\n";
+	content += "| ct-typescript-conventions | TypeScript strict mode and conventions |\n";
+	content += "| ct-verification-before-completion | Evidence-based completion claims protocol |\n";
+	content += "\n## Stack Skills\n\n";
+	content += "| Skill | Stack | Description |\n";
+	content += "|-------|-------|-------------|\n";
+
+	for (const stack of resolved.stacks) {
+		content += `| ${stack.name} | ${stack.name} | ${stack.description} |\n`;
+	}
+
+	content += "\n---\n\n*Generated from claude-toolkit.config.ts*\n";
+
+	await writeFileEnsureDir(join(claudeDir, "skills", "README.md"), content);
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export type {
+	ClaudeToolkitConfig,
+	GitConfig,
+	HookConfig,
+	ProjectInfo,
+	ResolvedConfig,
+	StackName,
+	StackPack,
+} from "./types.js";
+
+/**
+ * Define a claude-toolkit configuration with full type safety.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'claude-toolkit'
+ *
+ * export default defineConfig({
+ *   stacks: ['solidjs', 'rust-wasm', 'cloudflare'],
+ *   packageManager: 'bun',
+ *   hooks: {
+ *     formatter: 'bun run prettier --write',
+ *     testRunner: 'bun run vitest run',
+ *   },
+ * })
+ * ```
+ */
+export function defineConfig(config: import("./types.js").ClaudeToolkitConfig) {
+	return config;
+}