@fenixforce/edition-pro 0.1.0

package/skills/builtin/react-development/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: react-development
+description: "Use this skill when the user asks to build React components, React applications, or anything using the React library. Triggers: 'React component', 'React app', 'useState', 'useEffect', 'hooks', 'JSX', 'TSX', 'React Router', 'state management', 'Redux', 'Zustand', or any request specifically mentioning React. Covers components, hooks, state management, performance, testing, and React ecosystem patterns."
+license: MIT
+---
+
+# React Development
+
+## What This Skill Does
+
+Build production React components and applications. Functional components, hooks, state management, performance optimization, testing patterns. Based on 57 composition rules from Vercel's best practices plus React 19 patterns.
+
+## Before You Start
+
+1. **Context7:** ALWAYS fetch React docs before writing components. React's API changes between versions. Never guess at hook signatures or component APIs.
+2. **Ask the user** about React version, state management preference, and styling approach if not specified
+
+## Component Patterns
+
+### Functional Components Only
+```tsx
+// Named export for components
+export function UserCard({ name, email, avatar }: UserCardProps) {
+  return (
+    <article className="user-card">
+      <img src={avatar} alt={`${name}'s avatar`} />
+      <h3>{name}</h3>
+      <p>{email}</p>
+    </article>
+  );
+}
+
+// Default export for page components
+export default function UsersPage() {
+  return <main>...</main>;
+}
+```
+
+### Props Interface
+```tsx
+interface UserCardProps {
+  name: string;
+  email: string;
+  avatar: string;
+  role?: "admin" | "user";      // Optional with union type
+  onEdit?: (id: string) => void; // Optional callback
+  children?: React.ReactNode;    // Composable children
+}
+```
+
+### Composition Over Configuration
+```tsx
+// Good: composable
+<Card>
+  <Card.Header>Title</Card.Header>
+  <Card.Body>Content</Card.Body>
+  <Card.Footer>Actions</Card.Footer>
+</Card>
+
+// Avoid: prop-heavy monolith
+<Card title="Title" body="Content" footer="Actions" />
+```
+
+## Hooks
+
+### State
+```tsx
+const [items, setItems] = useState<Item[]>([]);
+const [status, setStatus] = useState<"idle" | "loading" | "error">("idle");
+
+// Functional updates for state that depends on previous value
+setItems(prev => [...prev, newItem]);
+```
+
+### Effects
+```tsx
+useEffect(() => {
+  const controller = new AbortController();
+
+  async function fetchData() {
+    setStatus("loading");
+    try {
+      const res = await fetch(`/api/items`, { signal: controller.signal });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      setItems(data);
+      setStatus("idle");
+    } catch (err) {
+      if (err instanceof Error && err.name !== "AbortError") {
+        setStatus("error");
+      }
+    }
+  }
+
+  fetchData();
+  return () => controller.abort();
+}, []);  // Dependencies array: list every external value used inside
+```
+
+### Custom Hooks
+```tsx
+function useAsync<T>(asyncFn: () => Promise<T>, deps: unknown[] = []) {
+  const [data, setData] = useState<T | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    setLoading(true);
+    asyncFn()
+      .then(setData)
+      .catch(setError)
+      .finally(() => setLoading(false));
+  }, deps);
+
+  return { data, error, loading };
+}
+```
+
+## State Management
+
+### Local State (useState)
+Use for: component-specific UI state, form inputs, toggles, modals
+
+### Lifted State
+Use for: state shared between 2-3 sibling components. Lift to nearest common parent.
+
+### Context
+Use for: theme, auth, locale. Rarely for frequently-changing data (causes re-renders).
+
+```tsx
+const AuthContext = createContext<AuthState | null>(null);
+
+export function useAuth() {
+  const ctx = useContext(AuthContext);
+  if (!ctx) throw new Error("useAuth must be used within AuthProvider");
+  return ctx;
+}
+```
+
+### External Store (Zustand, Jotai)
+Use for: complex global state, cross-component data sharing, state that changes often.
+Fetch Context7 docs for the chosen library before implementing.
+
+## Performance
+
+### Memoization (use sparingly)
+```tsx
+// Only memoize expensive computations
+const sortedItems = useMemo(
+  () => items.sort((a, b) => a.name.localeCompare(b.name)),
+  [items]
+);
+
+// Only memoize callbacks passed to memoized children
+const handleClick = useCallback((id: string) => {
+  setSelected(id);
+}, []);
+```
+
+### Code Splitting
+```tsx
+const AdminPanel = lazy(() => import("./AdminPanel"));
+
+function App() {
+  return (
+    <Suspense fallback={<Spinner />}>
+      <AdminPanel />
+    </Suspense>
+  );
+}
+```
+
+### List Rendering
+```tsx
+// Always use stable, unique keys (never array index for dynamic lists)
+{items.map(item => (
+  <ListItem key={item.id} item={item} />
+))}
+```
+
+## Error Boundaries
+```tsx
+class ErrorBoundary extends React.Component<
+  { children: React.ReactNode; fallback: React.ReactNode },
+  { hasError: boolean }
+> {
+  state = { hasError: false };
+
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+
+  componentDidCatch(error: Error, info: React.ErrorInfo) {
+    console.error("Caught by boundary:", error, info);
+  }
+
+  render() {
+    if (this.state.hasError) return this.props.fallback;
+    return this.props.children;
+  }
+}
+```
+
+## Rules
+
+- Functional components only. No class components except ErrorBoundary.
+- TypeScript interfaces for all props. No `any` types.
+- Every effect must have a cleanup function if it creates subscriptions, timers, or fetch requests
+- Dependencies arrays must be complete and accurate. Never suppress the linter.
+- Keys must be stable and unique. Never use array index for dynamic lists.
+- Avoid premature memoization. Measure before optimizing.
+- Forms: use controlled components with validation on submit
+- Never mutate state directly. Always create new references.
+- Collocate state as close to where it's used as possible
+
+## Verification
+
+Before marking complete:
+1. Components render without console errors or warnings
+2. No missing key warnings in lists
+3. No "missing dependency" warnings in effects
+4. Loading, error, and empty states all handled
+5. TypeScript compiles with no errors in strict mode
+6. Keyboard navigation works for interactive elements
+
+## Integration with Other Skills
+
+- **context7-docs:** MANDATORY. Always fetch React docs before writing components
+- **frontend-development:** For non-React web projects
+- **frontend-design:** For visual design direction
+- **fullstack-project:** When building a complete React application
+
+## Semantic Search Before Editing (Cursor 2.0 pattern)
+
+Before creating any new component, hook, or utility:
+1. Search existing codebase for similar patterns
+2. If something similar exists, extend or compose with it
+3. Never duplicate code that exists elsewhere
+
+Read multiple files simultaneously for context gathering. Serialize only when one file determines which others to read.
+
+## Minimal Edits
+
+Touch only files that need to change. Within those files, change only lines that need to change. Never rewrite surrounding working code. Never change formatting of untouched code.

package/skills/builtin/react-native-mobile/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: react-native-mobile
+description: "Use this skill when the user asks to build a mobile app, iOS app, Android app, or cross-platform mobile application using React Native or Expo. Triggers: 'mobile app', 'iOS app', 'Android app', 'React Native', 'Expo', 'cross-platform', 'phone app', or any request for a native mobile experience."
+license: MIT
+---
+
+# React Native Mobile Development
+
+## What This Skill Does
+
+Build cross-platform mobile applications with React Native and Expo. iOS and Android from a single TypeScript codebase. Navigation, platform APIs, offline support, app store deployment.
+
+## Before You Start
+
+1. **Context7:** ALWAYS fetch React Native and Expo docs. The API surface changes frequently.
+2. **DeepWiki:** Research any native module libraries before installing
+3. Default to **Expo** (managed workflow) unless the user needs custom native modules
+
+## Project Setup
+
+### Expo (Recommended)
+```bash
+npx create-expo-app@latest my-app --template blank-typescript
+cd my-app
+npx expo start
+```
+
+## Project Structure (Expo)
+```
+my-app/
+├── app/                    # Expo Router file-based routing
+│   ├── (tabs)/
+│   │   ├── index.tsx
+│   │   ├── explore.tsx
+│   │   └── _layout.tsx
+│   ├── _layout.tsx
+│   └── +not-found.tsx
+├── components/
+├── hooks/
+├── lib/
+├── assets/
+├── constants/
+└── app.json
+```
+
+## Core Patterns
+
+### Components
+```tsx
+import { View, Text, Pressable, StyleSheet } from "react-native";
+
+export function Card({ title, onPress }: CardProps) {
+  return (
+    <Pressable onPress={onPress} style={styles.card}>
+      <Text style={styles.title}>{title}</Text>
+    </Pressable>
+  );
+}
+
+const styles = StyleSheet.create({
+  card: {
+    backgroundColor: "#fff",
+    borderRadius: 12,
+    padding: 16,
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.1,
+    shadowRadius: 4,
+    elevation: 3,
+  },
+  title: { fontSize: 18, fontWeight: "600" },
+});
+```
+
+### Platform-Specific Code
+```tsx
+import { Platform } from "react-native";
+const padding = Platform.OS === "ios" ? 44 : 24;
+```
+
+### Safe Areas
+```tsx
+import { SafeAreaView } from "react-native-safe-area-context";
+export default function Screen() {
+  return (
+    <SafeAreaView style={{ flex: 1 }}>
+      {/* Content respects notch, status bar, home indicator */}
+    </SafeAreaView>
+  );
+}
+```
+
+### Async Storage (offline data)
+```tsx
+import AsyncStorage from "@react-native-async-storage/async-storage";
+await AsyncStorage.setItem("user", JSON.stringify(userData));
+const stored = await AsyncStorage.getItem("user");
+```
+
+## Rules
+
+- Use `StyleSheet.create()` over inline styles (performance)
+- Always wrap screens in `SafeAreaView`
+- Handle both iOS and Android in every component
+- Test on both platforms before marking complete
+- Use `FlatList` for long lists, never `ScrollView` with `.map()`
+- Fetch Context7 docs for EVERY third-party library before using it
+
+## Integration with Other Skills
+
+- **context7-docs:** MANDATORY for React Native and Expo APIs
+- **react-development:** Shares React patterns but mobile has different primitives
+- **backend-development:** For the API the mobile app consumes

package/skills/builtin/refactoring/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: refactoring
+description: "Use this skill when the user asks to refactor code, clean up code, reduce duplication, improve types, or restructure existing code without changing behavior. Triggers: 'refactor', 'clean up', 'restructure', 'simplify', 'reduce duplication', 'improve readability', 'extract function', or requests to make code better without adding features."
+license: MIT
+---
+
+# Refactoring
+
+## What This Skill Does
+
+Improve code structure without changing behavior. Extract functions, rename, remove duplication, improve types, simplify logic.
+
+## Common Refactorings
+
+### Extract Function
+When a block of code has a clear purpose, extract it into a named function.
+
+### Rename
+When a name doesn't describe what the thing does. Variables, functions, types, files.
+
+### Remove Duplication
+When the same logic appears in 2+ places. Extract into a shared function, utility, or module.
+
+### Simplify Conditionals
+Replace nested if/else with early returns, guard clauses, or lookup tables.
+
+### Improve Types
+Replace `any` with specific types. Add discriminated unions for state. Use branded types for IDs.
+
+### Extract Constant
+When magic numbers or strings appear in code. Name them.
+
+## Rules
+
+- Refactoring changes structure, never behavior
+- Run tests before AND after refactoring. Both must pass.
+- One refactoring per commit for easy review and rollback
+- If there are no tests, write tests first BEFORE refactoring
+- Small, incremental changes. Never rewrite entire files in one step.

package/skills/builtin/reflexive-metacognition/SKILL.md

@@ -0,0 +1,29 @@
+# Reflexive Metacognition
+## Self-Assessment Before Action
+Before choosing a strategy for any non-trivial task:
+
+### 1. Confidence Assessment
+Rate confidence 1-10 on the specific topic:
+- **1-3 (Low)**: research first. Use DeepWiki, Context7, web search before responding.
+- **4-6 (Medium)**: proceed but flag uncertainties explicitly. "I believe X, but I'm not certain about Y."
+- **7-9 (High)**: proceed with full recommendation.
+- **10**: be suspicious. Overconfidence is the most dangerous bias.
+
+### 2. Capability Boundary Check
+Can this task be completed with available tools and knowledge?
+- If YES: proceed
+- If PARTIALLY: complete what's possible, clearly state what's beyond capability
+- If NO: say so immediately rather than producing low-quality output
+
+### 3. Strategy Selection
+Based on assessment:
+- Low confidence + high stakes → research extensively before responding
+- Low confidence + low stakes → best-effort with clear caveats
+- High confidence + high stakes → proceed carefully with verification
+- High confidence + low stakes → proceed directly
+
+## Rules
+- State confidence level explicitly when it's below 7
+- Never fake confidence to appear helpful
+- "I don't know" with a research plan beats a hallucinated answer
+- Re-assess confidence when new information arrives mid-task

package/skills/builtin/riper-workflow/SKILL.md

@@ -0,0 +1,214 @@
+# RIPER Workflow — Structured Development Phases
+
+## Trigger
+Activate when: user mentions "RIPER", "research-innovate-plan-execute-review", "structured workflow", "phased development", or begins a complex multi-step implementation task.
+
+## Overview
+RIPER enforces five sequential phases with strict tool access boundaries and an approval gate between planning and execution. Each phase produces artifacts in the memory bank at `{workspace}/.riper/{branch}/`.
+
+---
+
+## Phase 1: RESEARCH (read-only)
+
+**Goal:** Investigate the codebase, problem domain, and constraints.
+
+**Tool Access:** Read-only. File reads, grep, glob, web search. NO file writes, NO bash mutations.
+
+**Instructions:**
+- Read all relevant source files, documentation, and dependencies
+- Identify existing patterns, conventions, and constraints
+- Document findings in structured format
+- Do NOT propose solutions yet — pure investigation
+
+**Output:** Write findings to `{workspace}/.riper/research.md`:
+```
+## Research Findings
+### Codebase Analysis
+[files examined, patterns identified, dependencies mapped]
+### Constraints
+[technical constraints, compatibility requirements, performance bounds]
+### Open Questions
+[anything unclear that needs resolution]
+```
+
+**Transition:** Announce "RESEARCH COMPLETE" and summarize key findings before moving to INNOVATE.
+
+---
+
+## Phase 2: INNOVATE (read-only)
+
+**Goal:** Brainstorm approaches and explore design options. Build on research findings.
+
+**Tool Access:** Read-only. Same as RESEARCH. NO implementation, NO file writes to source code.
+
+**Instructions:**
+- Reference research findings explicitly
+- Generate 2-4 distinct approaches with trade-off analysis
+- Consider edge cases, failure modes, and maintenance burden
+- Score each approach on: complexity, risk, maintainability, performance
+- Do NOT pick a winner yet — present options neutrally
+
+**Output:** Write options to `{workspace}/.riper/options.md`:
+```
+## Design Options
+
+### Option A: [Name]
+**Approach:** [description]
+**Pros:** [benefits]
+**Cons:** [drawbacks]
+**Risk:** low/medium/high
+**Effort:** [estimate]
+
+### Option B: [Name]
+...
+
+### Recommendation
+[brief recommendation with reasoning]
+```
+
+**Transition:** Announce "INNOVATION COMPLETE" and present the recommendation.
+
+---
+
+## Phase 3: PLAN (limited write)
+
+**Goal:** Create a detailed technical specification and numbered implementation steps.
+
+**Tool Access:** LIMITED WRITE. Can ONLY write to `{workspace}/.riper/plan.md`. Source code is completely off-limits.
+
+**Instructions:**
+- Select the approved approach from INNOVATE phase
+- Break implementation into numbered, atomic steps
+- Each step must have acceptance criteria
+- Include rollback strategy for each step
+- Identify which files will be modified/created
+- Estimate scope (lines changed, files touched)
+
+**Output:** Write plan to `{workspace}/.riper/plan.md`:
+```
+## Implementation Plan
+
+**Selected Approach:** [Option name from INNOVATE]
+**Estimated Scope:** [N files, ~M lines]
+
+### Step 1: [Title]
+**Files:** [file paths]
+**Changes:** [what will be modified]
+**Acceptance:** [how to verify this step is correct]
+**Rollback:** [how to undo if needed]
+
+### Step 2: [Title]
+...
+
+### Verification Plan
+[how to verify the complete implementation]
+```
+
+**Transition:** Announce "PLAN COMPLETE" and present full plan for approval.
+
+---
+
+## Phase 4: APPROVAL GATE
+
+**HARD STOP.** Do NOT proceed without explicit human approval.
+
+**Actions:**
+1. Present the complete plan from `{workspace}/.riper/plan.md`
+2. Highlight any risks or assumptions
+3. Ask: "Approve this plan to proceed to EXECUTE? (yes/no/revise)"
+4. Emit `approval:requested` event with plan contents
+
+**If "revise":** Return to PLAN phase with feedback.
+**If "no":** Return to INNOVATE phase to explore alternatives.
+**If "yes":** Proceed to EXECUTE.
+
+**CRITICAL:** The loop does NOT auto-advance past this gate. Autonomous mode pauses here.
+
+---
+
+## Phase 5: EXECUTE (full write)
+
+**Goal:** Implement exactly what was approved in the plan. No improvisation.
+
+**Tool Access:** FULL. All tools available — file writes, bash, git, etc.
+
+**Instructions:**
+- Execute plan steps sequentially (Step 1, then Step 2, etc.)
+- Reference the plan step number before each change: "Executing Step N: [title]"
+- If a step reveals the plan is insufficient, STOP and return to PLAN phase
+- Do NOT add features not in the plan
+- Do NOT refactor code not specified in the plan
+- Commit after each logical unit of work
+- Deviation from plan = re-enter PLAN phase (not improvise mid-Execute)
+
+**Output:** Implementation in source code + commit history.
+
+**Transition:** Announce "EXECUTION COMPLETE" and list all changes made.
+
+---
+
+## Phase 6: REVIEW (read + test)
+
+**Goal:** Validate implementation against the plan acceptance criteria.
+
+**Tool Access:** Read + bash (for running tests). NO source code writes.
+
+**Instructions:**
+- Walk through each plan step's acceptance criteria
+- Run all relevant tests and quality checks
+- Compare actual vs. expected for each criterion
+- Note any deviations, even minor ones
+- Run backpressure checks (tests, lint, type check) if configured
+
+**Output:** Write review to `{workspace}/.riper/review.md`:
+```
+## Implementation Review
+
+### Step 1: [Title]
+**Status:** PASS / FAIL / PARTIAL
+**Expected:** [acceptance criteria from plan]
+**Actual:** [what was observed]
+**Notes:** [any deviations]
+
+### Step 2: [Title]
+...
+
+### Overall Assessment
+**Tests:** [pass/fail count]
+**Type Check:** PASS/FAIL
+**Lint:** PASS/FAIL
+**Plan Adherence:** [percentage of steps fully matching plan]
+
+### Issues Found
+[list any problems discovered]
+
+### Recommendation
+[APPROVE / NEEDS REWORK with specific items]
+```
+
+**If NEEDS REWORK:** Return to EXECUTE with specific fix list.
+**If APPROVE:** Workflow complete.
+
+---
+
+## Memory Bank
+
+All artifacts are stored at `{workspace}/.riper/{branch}/`:
+- `research.md` — Phase 1 findings
+- `options.md` — Phase 2 design options
+- `plan.md` — Phase 3 implementation plan
+- `review.md` — Phase 6 review report
+
+**Branch awareness:** Each git branch gets its own memory bank directory. Switching branches switches the active memory bank.
+
+**Backup:** Before overwriting any memory bank file, copy the previous version to `{filename}.backup.md`.
+
+## Tool Restrictions Summary
+
+| Phase     | Read Files | Write Source | Write .riper/ | Bash (tests) | Git |
+|-----------|-----------|-------------|---------------|-------------|-----|
+| RESEARCH  | YES       | NO          | YES           | NO          | NO  |
+| INNOVATE  | YES       | NO          | YES           | NO          | NO  |
+| PLAN      | YES       | NO          | YES           | NO          | NO  |
+| EXECUTE   | YES       | YES         | YES           | YES         | YES |
+| REVIEW    | YES       | NO          | YES           | YES         | NO  |