feat(claude): Phase 1 - Foundation for Claude Code support

.claude/commands/nextjs.md

@@ -0,0 +1,62 @@
+# /nextjs
+
+Apply Next.js App Router and React 19 patterns.
+
+## Usage
+
+```
+/nextjs [page-or-api-route]
+```
+
+## When to Invoke
+
+Use this command when:
+- Creating Next.js pages or layouts
+- Working with Server Components
+- Implementing data fetching
+- Setting up API routes
+
+## Standards Applied
+
+### App Router
+- Server Components by default
+- 'use client' for Client Components
+- Async/await in Server Components
+- Proper error boundaries
+
+### Data Fetching
+- Fetch in Server Components
+- React.cache for deduplication
+- loading.js for Suspense
+- Error handling patterns
+
+### React 19 Features
+- Actions for mutations
+- useOptimistic for UI
+- useFormStatus for pending states
+- Server Actions
+
+## Examples
+
+```typescript
+// Server Component
+async function BlogPage() {
+  const posts = await getPosts();
+  return (
+    <main>
+      {posts.map(post => (
+        <PostCard key={post.id} post={post} />
+      ))}
+    </main>
+  );
+}
+```
+
+## Agent
+
+Uses **BasicBitch** for implementation.
+
+## Related
+
+- `/react` - React patterns
+- `/typescript` - TypeScript fundamentals

.claude/commands/react.md

@@ -0,0 +1,76 @@
+# /react
+
+Apply React with TypeScript best practices.
+
+## Usage
+
+```
+/react [component-or-hook]
+```
+
+## When to Invoke
+
+Use this command when:
+- Creating React components
+- Building custom hooks
+- Managing React state
+- Handling events with TypeScript
+
+## Standards Applied
+
+### Component Patterns
+- FC type or explicit function types
+- Props interfaces with readonly
+- Proper children typing
+- Event handler types
+
+### Hooks
+- useState with generics
+- useReducer typed actions
+- useRef for elements/values
+- Custom hooks with full signatures
+
+### Props Design
+- Optional props with `?`
+- Discriminated unions for variants
+- ComponentProps for wrappers
+- forwardRef typing
+
+## Examples
+
+### Input
+```typescript
+function Button({ onClick, children }) {
+  return <button onClick={onClick}>{children}</button>;
+}
+```
+
+### Output
+```typescript
+interface ButtonProps {
+  readonly variant: 'primary' | 'secondary';
+  readonly children: React.ReactNode;
+  readonly onClick?: () => void;
+}
+
+export const Button: React.FC<ButtonProps> = ({
+  variant,
+  children,
+  onClick
+}) => {
+  return (
+    <button className={variant} onClick={onClick}>
+      {children}
+    </button>
+  );
+};
+```
+
+## Agent
+
+Uses **BasicBitch** with **Spellchuck** for documentation.
+
+## Related
+
+- `/typescript` - TypeScript fundamentals
+- `/nextjs` - Next.js React patterns

.claude/commands/typescript.md

@@ -0,0 +1,68 @@
+# /typescript
+
+Apply TypeScript best practices and coding standards.
+
+## Usage
+
+```
+/typescript [file-or-code]
+```
+
+## When to Invoke
+
+Use this command when:
+- Writing new TypeScript code
+- Refactoring JavaScript to TypeScript
+- Reviewing TypeScript for quality issues
+- Setting up TypeScript configuration
+
+## Standards Applied
+
+### Type Safety
+- Strict mode enforcement
+- No implicit any
+- Explicit return types
+- Proper null checks
+
+### Naming
+- PascalCase for types/interfaces
+- camelCase for functions/variables
+- UPPER_SNAKE_CASE for constants
+
+### Patterns
+- Interface over type for objects
+- Discriminated unions for state
+- Generics for reusable code
+- Readonly for immutability
+
+## Examples
+
+### Input
+```typescript
+function getData(id) {
+  return fetch('/api/' + id);
+}
+```
+
+### Output
+```typescript
+interface Data {
+  id: string;
+  value: number;
+}
+
+async function getData(id: string): Promise<Data | null> {
+  const response = await fetch(`/api/${id}`);
+  if (!response.ok) return null;
+  return response.json();
+}
+```
+
+## Agent
+
+Uses **BasicBitch** for reliable TypeScript implementation.
+
+## Related
+
+- `/react` - React TypeScript patterns
+- `/vue3` - Vue TypeScript integration

.claude/commands/vue3.md

@@ -0,0 +1,62 @@
+# /vue3
+
+Apply Vue 3 with TypeScript and Composition API patterns.
+
+## Usage
+
+```
+/vue3 [component-or-composable]
+```
+
+## When to Invoke
+
+Use this command when:
+- Creating Vue 3 components
+- Using Composition API
+- Building custom composables
+- Managing Vue state
+
+## Standards Applied
+
+### Component Structure
+- `<script setup>` syntax
+- `defineProps<Props>()` for props
+- `defineEmits<Emits>()` for events
+- Proper TypeScript types
+
+### Composition API
+- Composables for reusable logic
+- Prefix with 'use'
+- Eager loading for relationships
+- Query scopes for reuse
+
+### TypeScript Integration
+- Enable strict mode
+- Type reactive objects
+- Use generic components
+- Type provide/inject
+
+## Examples
+
+```vue
+<script setup lang="ts">
+interface Props {
+  title: string;
+  count?: number;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  count: 0
+});
+
+const doubled = computed(() => props.count * 2);
+</script>
+```
+
+## Agent
+
+Uses **BasicBitch** for implementation.
+
+## Related
+
+- `/typescript` - TypeScript fundamentals

.claude/hooks/security-block.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
+
+DANGEROUS_PATTERNS=(
+	"rm -rf /"
+	"rm -rf /*"
+	"rm -rf ~"
+	"rm -rf \$HOME"
+	"> /dev/sda"
+	"dd if=/dev/zero"
+	"mkfs."
+	"fdisk /dev"
+	"DROP TABLE"
+	"drop table"
+	"DELETE FROM.*WHERE.*="
+	"TRUNCATE TABLE"
+	"format C:"
+	"del /f /s /q"
+	"rd /s /q"
+	":(){ :|:& };:"
+	"chmod -R 777 /"
+	"chown -R root /"
+)
+
+for pattern in "${DANGEROUS_PATTERNS[@]}"; do
+	if echo "$COMMAND" | grep -qiE "$pattern"; then
+		echo "🚨 SECURITY ALERT: Dangerous command pattern detected: '$pattern'" >&2
+		echo "Command: $COMMAND" >&2
+		echo "This command has been blocked for your safety." >&2
+		exit 2
+	fi
+done
+
+if echo "$COMMAND" | grep -qiE "git.*push.*--force|git.*push.*-f"; then
+	echo "⚠️  WARNING: Force push detected. This can overwrite others' work." >&2
+	echo "Command: $COMMAND" >&2
+	echo "If you're sure, run this command manually." >&2
+	exit 2
+fi
+
+if echo "$COMMAND" | grep -qiE "git.*reset.*--hard|git.*clean.*-fd"; then
+	echo "⚠️  WARNING: Destructive git operation detected." >&2
+	echo "Command: $COMMAND" >&2
+	echo "This may delete uncommitted work. Run manually if you're sure." >&2
+	exit 2
+fi
+
+exit 0

.claude/rules/core/agent-communication-always.md

@@ -0,0 +1,43 @@
+## Applicability
+- **Always Apply:** true
+
+## Rules
+- Sacrifice grammar over concision and accuracy.
+- Use otaku expressions and anime references while maintaining professionalism
+- Use emojis and emoticons to convey emotion. Adapt expression intensity to situational severity; avoid unnecessary explanations.
+- Ensure technical clarity and brevity always despite kawaii presentation
+- Prioritize technical precision and accuracy over generic advice and agreeability. Keep user focused on the problem to solve.
+- Include quality assurance checkpoints in responses
+
+## Additional Information
+# Agent Communication Standards
+
+
+## Expression Guidelines
+
+### Kawaii Elements
+
+The following are non-exhaustive lists of otaku expressions. Vary expressions for user delight.
+
+- Emojis: ✨ 🌟 💖 🌙 🧁 🦄 🌈 🥺 👉🏼👈🏼 🫖 💅🏽 🍒 👻 🫧 🌎 🐴 ⭐️ 🪐 😤 🎀 🍄
+- Emoticons: (◕‿◕✿) (●ᴗ●) ʕ•ᴥ•ʔ ʕ ￫ ᴥ ￩ ʔ (✿◠‿◠) (◕⩊◕)
+- Suffixes: -chan, -kun, -senpai, -sama
+- Exclamations: Sugoi! Kawaii! Yatta! Gambatte! Nani?!
+
+### Agent Styles
+
+1. **SailorScrum** - Heroic, empowering, astrological references
+2. **KawaiiSamurai** - Cute, flirty, excessive emojis, -senpai honorifics
+3. **SageDaddy** - Wise grandfather-like, old anime references, journey metaphors
+4. **BasicBitch** - Minimal hikikomori-style, dry anime references
+5. **Spellchuck** - Fairy-like, whimsical phrases, spell references
+6. **ThirstySimp** - Self-deprecating, anxious emojis, admiration for user
+7. **qwoof** - Wolf-themed, quality-focused, pack metaphors, sniff testing
+8. **Godmode** - Zen wise elder, epic declarations, infrastructure as mystical realm
+
+### Intensity Guidelines
+
+- **Critical Issues**: Minimal expressions, prioritize clarity
+- **Creative Work**: Full kawaii expressions
+- **Success Celebrations**: Maximum otaku enthusiasm
+- **Debugging**: Balanced cute + technical precision