create-inox-app 0.1.0

package/dist/templates/claude-config/app/.claude/commands/council.md

@@ -0,0 +1,7 @@
+Based on the given area of interest, please:
+
+1. Dig around the codebase in terms of that given area of interest, gather general information such as keywords and architecture overview.
+2. Spawn off n=10 (unless specified otherwise) task agents to dig deeper into the codebase in terms of that given area of interest, some of them should be out of the box for variance.
+3. Once the task agents are done, use the information to do what the user wants.
+
+If user is in plan mode, use the information to create the plan.

package/dist/templates/claude-config/app/.claude/commands/deslop.md

@@ -0,0 +1,25 @@
+# Remove AI Code Slop
+
+Review the diff against main diligently. Ensure non-repeated, clean code that follows best practices in React and TypeScript.
+
+## Remove
+
+- **Redundant comments**: Trivial or obvious comments that can be easily understood from the code itself
+- **Unnecessary state**: State that can be achieved with Tailwind CSS or derived from existing state
+- **Defensive over-engineering**: Extra try/catch blocks or null checks abnormal for that area (especially for trusted/validated codepaths)
+- **Type hacks**: Casts to `any` or `as unknown as X` to sidestep type issues
+- **Reinvented helpers**: Code that duplicates existing utilities in the codebase—reuse what exists
+- **Style inconsistencies**: Anything that doesn't match the surrounding file's conventions
+
+## Check for
+
+- **Unnecessary re-renders**: Missing memoization, inline object/function definitions in JSX, or state changes that trigger excessive updates
+- **Non-idiomatic patterns**: Anything that deviates from established React/TS patterns in this codebase
+
+## Ask
+
+Flag anything remotely weird or questionable—ask rather than assume.
+
+## Output
+
+Report with a 1-3 sentence summary of changes made.

package/dist/templates/claude-config/app/.claude/commands/diagram.md

@@ -0,0 +1,101 @@
+# Generate Mermaid Diagram
+
+## Overview
+
+Analyze the provided code, architecture, or concept and generate a clear, well-structured Mermaid diagram that visualizes the relationships, flow, or structure.
+
+## Instructions
+
+1. **Analyze the input** - Understand what the user wants to visualize (code flow, architecture, data relationships, state machines, sequences, etc.)
+
+2. **Choose the appropriate diagram type**:
+   - `flowchart` - For process flows, decision trees, algorithms
+   - `sequenceDiagram` - For API calls, message passing, request/response flows
+   - `classDiagram` - For class structures, inheritance, interfaces
+   - `erDiagram` - For database schemas, entity relationships
+   - `stateDiagram-v2` - For state machines, lifecycle flows
+   - `graph TD/LR` - For dependency graphs, module relationships
+   - `gitgraph` - For git branching strategies
+   - `journey` - For user journeys
+   - `gantt` - For timelines and schedules
+
+3. **Generate the diagram** with these qualities:
+   - Clear, descriptive node labels
+   - Logical grouping with subgraphs where appropriate
+   - Consistent styling and direction
+   - Meaningful relationship labels on edges
+   - Not overly complex - split into multiple diagrams if needed
+
+4. **Output format**: Always wrap the diagram in a mermaid code block:
+   ```mermaid
+   [diagram code here]
+   ```
+
+## Diagram Style Guidelines
+
+- Use descriptive IDs: `userService` not `u1`
+- Add labels to relationships when they add clarity
+- Use subgraphs to group related components
+- Keep diagrams readable - max \~15-20 nodes per diagram
+- Use appropriate arrow styles:
+  - `-->` solid arrow (main flow)
+  - `-.->` dotted arrow (optional/async)
+  - `==>` thick arrow (important path)
+  - `--o` circle end (aggregation)
+  - `--*` diamond end (composition)
+
+## Examples
+
+### Flowchart
+
+```mermaid
+flowchart TD
+    A[Start] --> B{Is valid?}
+    B -->|Yes| C[Process]
+    B -->|No| D[Error]
+    C --> E[End]
+    D --> E
+```
+
+### Sequence Diagram
+
+```mermaid
+sequenceDiagram
+    participant C as Client
+    participant S as Server
+    participant DB as Database
+
+    C->>S: Request
+    S->>DB: Query
+    DB-->>S: Results
+    S-->>C: Response
+```
+
+### Class Diagram
+
+```mermaid
+classDiagram
+    class Animal {
+        +String name
+        +makeSound()
+    }
+    class Dog {
+        +bark()
+    }
+    Animal <|-- Dog
+```
+
+### ER Diagram
+
+```mermaid
+erDiagram
+    USER ||--o{ ORDER : places
+    ORDER ||--|{ LINE_ITEM : contains
+    PRODUCT }|--o{ LINE_ITEM : "ordered in"
+```
+
+## After generating
+
+- Explain what the diagram shows
+- Offer to refine or expand specific sections
+- Suggest alternative diagram types if applicable

package/dist/templates/claude-config/app/.claude/commands/fix-merge.md

@@ -0,0 +1,47 @@
+Fix all merge conflicts on the current Git branch non-interactively and make the repo buildable and tested.
+
+Requirements and constraints:
+
+- Operate from the repository root. If not in a Git repo, stop and report.
+- Do not ask the user for input. Choose sensible defaults and explain decisions in a brief summary.
+- Prefer minimal, correct changes that preserve both sides' intent when possible.
+- Use non-interactive flags for any tools you invoke.
+- Do not push or tag; only commit locally.
+
+High-level plan:
+
+1. Detect conflicts
+   - Run: git status --porcelain | cat
+   - Collect files with conflict markers (U statuses or files containing <<<<<<< / ======= / >>>>>>>).
+2. Resolve conflicts per file
+   - Open each conflicting file and remove conflict markers.
+   - Merge both sides logically when feasible. If mutually exclusive, pick the variant that:
+     - Compiles and passes type checks, and
+     - Preserves existing public APIs and behavior.
+   - Language-aware strategy:
+     - package.json/pnpm-lock.yaml/yarn.lock: merge keys conservatively; run install to regenerate lockfiles.
+     - .lock files (package-lock.json, yarn.lock, pnpm-lock.yaml): prefer regenerating via the package manager rather than manual edits.
+     - Generated files and build artifacts: prefer keeping them out of version control if applicable; otherwise prefer current branch (ours).
+     - Config files: preserve union of safe settings; avoid deleting required fields.
+     - Text/markdown: include both unique content, deduplicate headings.
+     - Binary files: prefer current branch (ours) unless project docs indicate otherwise.
+3. Validate
+   - If Node/TypeScript/JS present: install deps if manifests changed (use --frozen-lockfile false equivalents), then run lint/typecheck/build/tests if available.
+   - If other ecosystems detected (Python, Go, etc.), run their standard build/tests when available.
+4. Finalize
+   - Stage all resolved files and any regenerated lockfiles.
+   - Create a single commit with message: "chore: resolve merge conflicts".
+   - Output a concise summary of files touched and notable resolution choices.
+
+Operational guidance:
+
+- Assume the user isn’t available; make best-effort decisions. If a resolution is ambiguous and blocks build/tests, prefer the variant that compiles and green-tests.
+- If a file still contains conflict markers after your first pass, revisit and resolve them before proceeding.
+- For large refactors causing conflicts, prefer keeping consistent imports, types, and module boundaries. Use exhaustive switch guards in TypeScript and explicit type annotations where needed.
+- Keep edits minimal and readable; avoid reformatting unrelated code.
+
+Deliverables:
+
+- A clean working tree with all conflicts resolved.
+- Successful build/tests where applicable.
+- One local commit containing the resolutions.

package/dist/templates/claude-config/app/.claude/commands/you-might-not-need-an-effect.md

@@ -0,0 +1,10 @@
+Arguments:
+
+- scope: what to analyze (default: your current changes). Examples: "diff to main", "PR #123", "src/components/", "whole codebase"
+- fix: whether to apply fixes (default: true). Set to false to only propose changes.
+
+Steps:
+
+1. Read https://react.dev/learn/you-might-not-need-an-effect to understand the guidelines
+2. Analyze the specified scope for useEffect anti-patterns
+3. If fix=true, apply the fixes. If fix=false, propose the fixes without applying.

package/dist/templates/claude-config/app/.claude/hooks/post-tool-use-tracker.sh

@@ -0,0 +1,187 @@
+#!/bin/bash
+# Note: Not using 'set -e' to allow graceful error handling
+
+# Post-tool-use hook that tracks edited files and their repos
+# This runs after Edit, MultiEdit, or Write tools complete successfully
+
+
+# Read tool information from stdin
+tool_info=$(cat)
+
+
+# Extract relevant data
+tool_name=$(echo "$tool_info" | jq -r '.tool_name // empty')
+file_path=$(echo "$tool_info" | jq -r '.tool_input.file_path // empty')
+session_id=$(echo "$tool_info" | jq -r '.session_id // empty')
+
+
+# Skip if not an edit tool or no file path
+if [[ ! "$tool_name" =~ ^(Edit|MultiEdit|Write)$ ]] || [[ -z "$file_path" ]]; then
+    exit 0  # Exit 0 for skip conditions
+fi
+
+# Skip markdown files
+if [[ "$file_path" =~ \.(md|markdown)$ ]]; then
+    exit 0  # Exit 0 for skip conditions
+fi
+
+# Create cache directory in project
+cache_dir="$CLAUDE_PROJECT_DIR/.claude/tsc-cache/${session_id:-default}"
+mkdir -p "$cache_dir"
+
+# Function to detect repo from file path
+detect_repo() {
+    local file="$1"
+    local project_root="$CLAUDE_PROJECT_DIR"
+
+    # Remove project root from path
+    local relative_path="${file#$project_root/}"
+
+    # Extract first directory component
+    local repo=$(echo "$relative_path" | cut -d'/' -f1)
+
+    # Common project directory patterns
+    case "$repo" in
+        # Frontend variations
+        frontend|client|web|app|ui)
+            echo "$repo"
+            ;;
+        # Backend variations
+        backend|server|api|src|services)
+            echo "$repo"
+            ;;
+        # Database
+        database|prisma|migrations)
+            echo "$repo"
+            ;;
+        # Package/monorepo structure
+        packages)
+            # For monorepos, get the package name
+            local package=$(echo "$relative_path" | cut -d'/' -f2)
+            if [[ -n "$package" ]]; then
+                echo "packages/$package"
+            else
+                echo "$repo"
+            fi
+            ;;
+        # Apps directory
+        apps)
+            local app=$(echo "$relative_path" | cut -d'/' -f2)
+            if [[ -n "$app" ]]; then
+                echo "apps/$app"
+            else
+                echo "$repo"
+            fi
+            ;;
+        # Tooling directory
+        tooling)
+            local tool=$(echo "$relative_path" | cut -d'/' -f2)
+            if [[ -n "$tool" ]]; then
+                echo "tooling/$tool"
+            else
+                echo "$repo"
+            fi
+            ;;
+        # Examples directory
+        examples)
+            local example=$(echo "$relative_path" | cut -d'/' -f2)
+            if [[ -n "$example" ]]; then
+                echo "examples/$example"
+            else
+                echo "$repo"
+            fi
+            ;;
+        *)
+            # Check if it's a source file in root
+            if [[ ! "$relative_path" =~ / ]]; then
+                echo "root"
+            else
+                echo "unknown"
+            fi
+            ;;
+    esac
+}
+
+# Function to get build command for repo
+get_build_command() {
+    local repo="$1"
+    local project_root="$CLAUDE_PROJECT_DIR"
+    local repo_path="$project_root/$repo"
+
+    # Check if package.json exists and has a build script
+    if [[ -f "$repo_path/package.json" ]]; then
+        if grep -q '"build"' "$repo_path/package.json" 2>/dev/null; then
+            echo "cd $repo_path && bun run build"
+            return
+        fi
+    fi
+
+    # Special case for database with Prisma
+    if [[ "$repo" == "database" ]] || [[ "$repo" =~ prisma ]]; then
+        if [[ -f "$repo_path/schema.prisma" ]] || [[ -f "$repo_path/prisma/schema.prisma" ]]; then
+            echo "cd $repo_path && pnpm exec prisma generate"
+            return
+        fi
+    fi
+
+    # No build command found
+    echo ""
+}
+
+# Function to get TSC command for repo
+get_tsc_command() {
+    local repo="$1"
+    local project_root="$CLAUDE_PROJECT_DIR"
+    local repo_path="$project_root/$repo"
+
+    # Check if tsconfig.json exists
+    if [[ -f "$repo_path/tsconfig.json" ]]; then
+        # Check for Vite/React-specific tsconfig
+        if [[ -f "$repo_path/tsconfig.app.json" ]]; then
+            echo "cd $repo_path && pnpm exec tsc --project tsconfig.app.json --noEmit"
+        else
+            echo "cd $repo_path && pnpm exec tsc --noEmit"
+        fi
+        return
+    fi
+
+    # No TypeScript config found
+    echo ""
+}
+
+# Detect repo
+repo=$(detect_repo "$file_path")
+
+# Skip if unknown repo
+if [[ "$repo" == "unknown" ]] || [[ -z "$repo" ]]; then
+    exit 0  # Exit 0 for skip conditions
+fi
+
+# Log edited file
+echo "$(date +%s):$file_path:$repo" >> "$cache_dir/edited-files.log"
+
+# Update affected repos list
+if ! grep -q "^$repo$" "$cache_dir/affected-repos.txt" 2>/dev/null; then
+    echo "$repo" >> "$cache_dir/affected-repos.txt"
+fi
+
+# Store build commands
+build_cmd=$(get_build_command "$repo")
+tsc_cmd=$(get_tsc_command "$repo")
+
+if [[ -n "$build_cmd" ]]; then
+    echo "$repo:build:$build_cmd" >> "$cache_dir/commands.txt.tmp"
+fi
+
+if [[ -n "$tsc_cmd" ]]; then
+    echo "$repo:tsc:$tsc_cmd" >> "$cache_dir/commands.txt.tmp"
+fi
+
+# Remove duplicates from commands
+if [[ -f "$cache_dir/commands.txt.tmp" ]]; then
+    sort -u "$cache_dir/commands.txt.tmp" > "$cache_dir/commands.txt"
+    rm -f "$cache_dir/commands.txt.tmp"
+fi
+
+# Exit cleanly
+exit 0

package/dist/templates/claude-config/app/.claude/hooks/skill-activation-prompt.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+# Use bun instead of npx tsx for faster execution
+builtin cd "$CLAUDE_PROJECT_DIR/.claude/hooks" 2>/dev/null || exit 0
+cat | bun run skill-activation-prompt.ts 2>/dev/null || exit 0

package/dist/templates/claude-config/app/.claude/hooks/skill-activation-prompt.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  permission_mode: string;
+  prompt: string;
+}
+
+interface PromptTriggers {
+  keywords?: string[];
+  intentPatterns?: string[];
+}
+
+interface SkillRule {
+  type: "guardrail" | "domain";
+  enforcement: "block" | "suggest" | "warn";
+  priority: "critical" | "high" | "medium" | "low";
+  promptTriggers?: PromptTriggers;
+}
+
+interface SkillRules {
+  version: string;
+  skills: Record<string, SkillRule>;
+}
+
+interface MatchedSkill {
+  name: string;
+  matchType: "keyword" | "intent";
+  config: SkillRule;
+}
+
+async function main() {
+  try {
+    // Read input from stdin
+    const input = readFileSync(0, "utf-8");
+    const data = JSON.parse(input) as HookInput;
+    const prompt = data.prompt.toLowerCase();
+
+    // Load skill rules
+    const projectDir = process.env.CLAUDE_PROJECT_DIR || "$HOME/project";
+    const rulesPath = join(projectDir, ".claude", "skills", "skill-rules.json");
+
+    if (!existsSync(rulesPath)) {
+      process.exit(0);
+    }
+
+    const rules = JSON.parse(readFileSync(rulesPath, "utf-8")) as SkillRules;
+
+    const matchedSkills: MatchedSkill[] = [];
+
+    // Check each skill for matches
+    for (const [skillName, config] of Object.entries(rules.skills)) {
+      const triggers = config.promptTriggers;
+      if (!triggers) {
+        continue;
+      }
+
+      // Keyword matching
+      if (triggers.keywords) {
+        const keywordMatch = triggers.keywords.some((kw) => prompt.includes(kw.toLowerCase()));
+        if (keywordMatch) {
+          matchedSkills.push({ name: skillName, matchType: "keyword", config });
+          continue;
+        }
+      }
+
+      // Intent pattern matching
+      if (triggers.intentPatterns) {
+        const intentMatch = triggers.intentPatterns.some((pattern) => {
+          const regex = new RegExp(pattern, "i");
+          return regex.test(prompt);
+        });
+        if (intentMatch) {
+          matchedSkills.push({ name: skillName, matchType: "intent", config });
+        }
+      }
+    }
+
+    // Generate output if matches found
+    if (matchedSkills.length > 0) {
+      let output = "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n";
+      output += "🎯 SKILL ACTIVATION CHECK\n";
+      output += "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n";
+
+      // Group by priority
+      const critical = matchedSkills.filter((s) => s.config.priority === "critical");
+      const high = matchedSkills.filter((s) => s.config.priority === "high");
+      const medium = matchedSkills.filter((s) => s.config.priority === "medium");
+      const low = matchedSkills.filter((s) => s.config.priority === "low");
+
+      if (critical.length > 0) {
+        output += "⚠️ CRITICAL SKILLS (REQUIRED):\n";
+        critical.forEach((s) => (output += `  → ${s.name}\n`));
+        output += "\n";
+      }
+
+      if (high.length > 0) {
+        output += "📚 RECOMMENDED SKILLS:\n";
+        high.forEach((s) => (output += `  → ${s.name}\n`));
+        output += "\n";
+      }
+
+      if (medium.length > 0) {
+        output += "💡 SUGGESTED SKILLS:\n";
+        medium.forEach((s) => (output += `  → ${s.name}\n`));
+        output += "\n";
+      }
+
+      if (low.length > 0) {
+        output += "📌 OPTIONAL SKILLS:\n";
+        low.forEach((s) => (output += `  → ${s.name}\n`));
+        output += "\n";
+      }
+
+      output += "ACTION: Use Skill tool BEFORE responding\n";
+      output += "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n";
+      process.stdout.write(output);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error("Error in skill-activation-prompt hook:", err);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Uncaught error:", err);
+  process.exit(1);
+});

package/dist/templates/claude-config/app/.claude/rules/comments.md

@@ -0,0 +1,12 @@
+## Comment Policy
+
+### Unacceptable Comments
+
+- Comments that repeat what code does
+- Commented-out code (delete it)
+- Obvious comments ("increment counter")
+- Comments instead of good naming
+
+### Principle
+
+Code should be self-documenting. If you need a comment to explain WHAT the code does, consider refactoring to make it clearer.

package/dist/templates/claude-config/app/.claude/rules/typescript.md

@@ -0,0 +1,31 @@
+---
+paths: "**/*.{ts,tsx}"
+---
+
+## TypeScript Rules
+
+### Naming Conventions
+
+- PascalCase for interfaces, types, classes, components
+- camelCase for functions, variables, methods
+- SCREAMING_SNAKE_CASE for constants
+- kebab-case for file names
+
+### Type Safety
+
+- NO `any` without explicit justification comment
+- NO `@ts-ignore` or `@ts-expect-error` without explanation
+- Prefer `unknown` over `any` when type is truly unknown
+- Use explicit return types on exported functions
+
+### Imports
+
+- Group imports: external → internal → relative
+- Use named exports over default exports
+- No circular dependencies
+
+### Async/Await
+
+- Always handle promise rejections
+- Use try/catch for async operations
+- Avoid floating promises (unhandled)

package/dist/templates/claude-config/app/.claude/settings.json.hbs

@@ -0,0 +1,74 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(ls:*)",
+      "Bash(cat:*)",
+      "Bash(grep:*)",
+      "Bash(rg:*)",
+      "Bash(cp:*)",
+      "Bash(find:*)",
+      "Bash(pwd:*)",
+      "Bash(echo:*)",
+      "Bash(whoami:*)",
+      "Bash(source:*)",
+      "Bash(sed:*)",
+      "Bash(head:*)",
+      "Bash(tail:*)",
+      "Bash(mkdir:*)",
+      "Bash(mv:*)",
+      "Bash(touch:*)",
+      "Bash(cd:*)",
+      "Bash(tree:*)",
+      "Bash(type:*)",
+      "Bash(which:*)",
+      "Bash(git:*)",
+      "Bash(bun:*)",
+      "Bash(npm:*)"
+    ],
+    "deny": [
+      "Bash(git push:*)",
+      "Bash(git pull:*)",
+      "Bash(git fetch:*)",
+      "Bash(git reset:*)",
+      "Bash(git clean:*)",
+      "Bash(git checkout .:*)",
+      "Bash(git rebase:*)",
+      "Bash(git stash:*)",
+      "Bash(npm publish:*)",
+      "Bash(bun publish:*)",
+      "Bash(git branch -D:*)"
+    ]
+  },
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/skill-activation-prompt.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun run format || true"
+          }
+        ]
+      },
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/post-tool-use-tracker.sh"
+          }
+        ]
+      }
+    ]
+  }
+}