davenov-cc 1.0.0

package/README.md

@@ -0,0 +1,106 @@
+# Claude Code Customizations Collection
+
+A personal collection of Claude Code customizations including skills and slash commands.
+
+## Contents
+
+### Commands (`commands/`)
+
+Slash commands that can be invoked with `/<command-name>`:
+
+- **davenov:cc:interview** - Interview mode for expanding specifications
+- **davenov:cc:rule** - Create or modify Claude Code rules
+- **davenov:cc:update** - Update to latest version and sync to ~/.claude/
+
+### Skills (`skills/`)
+
+Skills provide Claude with domain-specific knowledge and workflows:
+
+- **davenov:cc:expert-convex-nextjs** - Building full-stack apps with Convex backend and Next.js frontend
+- **davenov:cc:expert-evolu-nextjs** - Local-first apps with Evolu and Next.js (offline-first, e2e encryption)
+- **davenov:cc:expert-nextjs-16** - Next.js 16 patterns including Cache Components, Server Actions, and more
+- **davenov:cc:expert-build-nostr** - Building Nostr applications for decentralized data exchange
+
+## Installation
+
+Requires Node.js (no additional dependencies).
+
+```bash
+npx davenov-cc
+```
+
+That's it! The installer will copy all commands and skills to `~/.claude/`.
+
+## Updating
+
+Update from any directory using the slash command:
+
+```
+/davenov:cc:update
+```
+
+Or run the npx command directly:
+
+```bash
+npx davenov-cc@latest
+```
+
+The `@latest` tag ensures you get the newest version.
+
+### Behavior with existing files
+
+- **Merges directories** - Existing directories are preserved, not deleted
+- **Overwrites matching files** - Files with the same path get overwritten
+- **Preserves unrelated files** - Your other customizations in `~/.claude/` remain untouched
+
+> **Note:** If you delete a file from this repo, it won't be removed from `~/.claude/` on reinstall. Manually delete unwanted files or remove the entire `~/.claude/commands/` or `~/.claude/skills/` directory before reinstalling for a clean slate.
+
+## Structure
+
+```
+.
+├── bin/
+│   └── cli.js          # npx entry point
+├── commands/           # Slash commands (*.md files)
+│   ├── davenov:cc:interview.md
+│   ├── davenov:cc:rule.md
+│   └── davenov:cc:update.md
+├── skills/             # Skills with references and workflows
+│   └── <skill-name>/
+│       ├── SKILL.md        # Main skill definition
+│       ├── references/     # Reference documentation
+│       ├── workflows/      # Step-by-step workflows
+│       └── templates/      # Code templates (optional)
+├── package.json        # npm package configuration
+├── install.js          # Installation script
+└── README.md
+```
+
+## Adding new customizations
+
+### Adding a command
+
+Create a new `.md` file in `commands/`:
+
+```bash
+commands/my-command.md
+```
+
+### Adding a skill
+
+Create a new directory in `skills/` with at least a `SKILL.md`:
+
+```bash
+skills/my-skill/
+├── SKILL.md
+├── references/
+│   └── ...
+└── workflows/
+    └── ...
+```
+
+After adding new customizations, run `node install.js` again to install them.
+
+## Acknowledgments
+
+Most resources in this collection were created with the help of [taches-cc-resources](https://github.com/glittercowboy/taches-cc-resources), an excellent toolkit for building Claude Code customizations.

package/bin/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Run install.js from the package root with --auto-override
+const installScript = path.join(__dirname, '..', 'install.js');
+
+const child = spawn(process.execPath, [installScript, '--auto-override'], {
+  stdio: 'inherit',
+  cwd: path.join(__dirname, '..')
+});
+
+child.on('close', (code) => {
+  process.exit(code);
+});

package/commands/davenov:cc:interview.md

@@ -0,0 +1,12 @@
+---
+argument-hint: [spec-file]
+description: Interview me to expand the spec
+---
+
+Here's the current spec:
+
+@$ARGUMENTS
+
+Interview me in detail using the AskUserQuestion tool about literally anything: technical implementation, UI & UX, concerns, tradeoffs, etc. but make sure the questions are not obvious.
+
+Be very in-depth and continue interviewing me until it's complete, then write the spec back to $ARGUMENTS.

package/commands/davenov:cc:rule.md

@@ -0,0 +1,275 @@
+---
+name: rule
+description: Create or modify Claude Code rules with best practices guidance
+argument-hint: <description of the rule>
+allowed-tools:
+  - Read
+  - Write
+  - Glob
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Create or modify Claude Code rule files (.md) that follow best practices for the `.claude/rules/` system.
+
+Rules provide focused, well-organized instructions that Claude automatically loads as project memory.
+</objective>
+
+<context>
+Before proceeding, gather context about existing rules:
+
+```bash
+# Check for existing user-level rules
+ls -la ~/.claude/rules/ 2>/dev/null || echo "No user-level rules directory"
+
+# Check for existing project-level rules (if in a project)
+ls -la .claude/rules/ 2>/dev/null || echo "No project-level rules directory"
+```
+
+Read any relevant existing rules to understand current patterns.
+</context>
+
+<process>
+
+<step name="validate_input">
+**Check if description was provided:**
+
+- **With arguments ($ARGUMENTS):** Use as the rule description/intent
+- **Without arguments:** Use AskUserQuestion to get the rule description:
+  - header: "Rule Intent"
+  - question: "What behavior or guideline should this rule enforce? Describe what you want Claude to do or avoid."
+  - options:
+    - "Code style" — formatting, naming conventions, patterns
+    - "Workflow" — processes, git conventions, testing requirements
+    - "Architecture" — file structure, dependencies, design patterns
+</step>
+
+<step name="determine_scope">
+Use AskUserQuestion to determine rule scope:
+
+- header: "Rule Scope"
+- question: "Where should this rule be saved?"
+- options:
+  - "User-level (~/.claude/rules/)" — applies to all your projects
+  - "Project-level (.claude/rules/)" — applies only to current project
+</step>
+
+<step name="determine_path_specificity">
+Use AskUserQuestion to determine if rule should be path-specific:
+
+- header: "Path Scope"
+- question: "Should this rule apply to all files or only specific file types/paths?"
+- options:
+  - "All files (Recommended)" — rule loads unconditionally
+  - "Specific paths" — rule only loads when working with matching files
+</step>
+
+<step name="gather_path_patterns" condition="if path-specific selected">
+Use AskUserQuestion to gather path patterns:
+
+- header: "File Patterns"
+- question: "What file patterns should this rule apply to? (e.g., 'src/**/*.ts', '**/*.test.js')"
+- options:
+  - "TypeScript/JavaScript" — src/**/*.{ts,tsx,js,jsx}
+  - "Tests" — **/*.{test,spec}.{ts,tsx,js,jsx}
+  - "API routes" — src/api/**/*.ts
+  - multiSelect: true
+
+If user selects "Other", validate their custom glob pattern.
+</step>
+
+<step name="analyze_and_clarify">
+Analyze the rule description for:
+
+1. **Clarity**: Is the intent unambiguous?
+2. **Actionability**: Can Claude act on this?
+3. **Specificity**: Is it precise enough to follow consistently?
+4. **Conflict potential**: Could it contradict common patterns?
+
+If any issues found, use AskUserQuestion to clarify:
+
+- header: "Clarification"
+- question: "[Specific question about ambiguity]"
+- options: [Context-appropriate options]
+
+Common clarifications needed:
+- "Always" vs "prefer" vs "when appropriate"
+- Specific file types or directories
+- Exception cases
+- Priority relative to other guidelines
+</step>
+
+<step name="determine_organization">
+Use AskUserQuestion to determine file organization:
+
+- header: "Organization"
+- question: "How should this rule be organized?"
+- options:
+  - "New file (Recommended)" — create dedicated rule file
+  - "Add to existing" — append to an existing rule file
+  - "Subdirectory" — organize under a category folder
+</step>
+
+<step name="generate_filename">
+Generate a descriptive filename:
+
+- Use lowercase with hyphens
+- Be descriptive but concise (e.g., `code-style.md`, `testing-conventions.md`)
+- Match the rule's topic
+
+If subdirectory selected, determine category:
+- `frontend/` — React, CSS, UI patterns
+- `backend/` — API, database, server patterns
+- `tooling/` — build, CI/CD, scripts
+- `general/` — cross-cutting concerns
+</step>
+
+<step name="compose_rule">
+Compose the rule following best practices:
+
+**Structure:**
+```markdown
+---
+paths:
+  - "pattern/**/*.ext"  # Only if path-specific
+---
+
+# [Rule Title]
+
+[Brief context - 1-2 sentences explaining why this rule exists]
+
+## Guidelines
+
+- [Specific, actionable guideline]
+- [Another guideline]
+
+## Examples
+
+### Do
+[Good example with explanation]
+
+### Don't
+[Bad example with explanation]
+```
+
+**Best Practices to Follow:**
+1. **Be specific**: "Use camelCase for variables" not "follow naming conventions"
+2. **Be actionable**: Each point should be something Claude can do
+3. **Provide examples**: Show what good and bad look like
+4. **Explain rationale**: Help Claude understand *why*
+5. **Keep focused**: One topic per file
+6. **Use imperative mood**: "Use X" not "You should use X"
+7. **Avoid redundancy**: Don't repeat what's in other rules
+</step>
+
+<step name="validate_rule">
+Before writing, validate the rule:
+
+1. **Check for conflicts** with existing rules:
+   ```bash
+   grep -r "[key terms]" ~/.claude/rules/ .claude/rules/ 2>/dev/null
+   ```
+
+2. **Verify clarity**: Each guideline should pass the "can Claude act on this?" test
+
+3. **Check length**: Rules should be scannable, not walls of text
+
+If validation finds issues, refine the rule content.
+</step>
+
+<step name="create_directories">
+Ensure the target directory exists:
+
+```bash
+# For user-level rules
+mkdir -p ~/.claude/rules/
+
+# For project-level rules
+mkdir -p .claude/rules/
+```
+
+If using subdirectory organization:
+```bash
+mkdir -p [target-path]/[subdirectory]/
+```
+</step>
+
+<step name="write_rule">
+Write the rule file to the determined path:
+
+```bash
+# Construct full path based on scope and organization decisions
+```
+
+Write the composed rule content to the file.
+</step>
+
+<step name="confirm">
+Display confirmation:
+
+```
+Rule created: [full path]
+
+[Rule title]
+Scope: [user-level | project-level]
+Applies to: [all files | specific paths]
+
+Preview:
+---
+[First few lines of the rule]
+---
+
+The rule will be automatically loaded in future Claude sessions.
+```
+</step>
+
+</process>
+
+<best_practices>
+## Rule Writing Best Practices
+
+**DO:**
+- Keep rules focused on one topic
+- Use descriptive filenames
+- Provide concrete examples
+- Explain the "why" behind guidelines
+- Use path-specific rules only when truly needed
+- Test that guidelines are actionable
+
+**DON'T:**
+- Create overly broad "catch-all" rules
+- Duplicate guidelines across multiple files
+- Use vague language ("be careful", "consider")
+- Add path frontmatter unless genuinely path-specific
+- Create rules for one-off preferences
+- Include time-sensitive information
+</best_practices>
+
+<validation_questions>
+When reviewing a rule, verify:
+
+1. **Necessity**: Does this rule add value not covered elsewhere?
+2. **Clarity**: Could another developer understand and follow this?
+3. **Consistency**: Does it align with existing rules?
+4. **Scope**: Is the path specificity appropriate?
+5. **Actionability**: Can Claude act on every guideline?
+6. **Examples**: Are good/bad examples clear?
+</validation_questions>
+
+<output>
+- Rule file at determined path
+- Confirmation with preview
+</output>
+
+<success_criteria>
+- [ ] Rule description obtained and understood
+- [ ] Scope (user vs project) determined
+- [ ] Path specificity determined (if applicable)
+- [ ] Ambiguities clarified through questions
+- [ ] Rule follows best practices structure
+- [ ] No conflicts with existing rules
+- [ ] Directory structure created
+- [ ] Rule file written successfully
+- [ ] Confirmation displayed
+</success_criteria>

package/commands/davenov:cc:update.md

@@ -0,0 +1,21 @@
+---
+description: Update davenov-cc-collection to latest version and sync to ~/.claude/
+allowed-tools:
+  - Bash
+---
+
+# Update davenov-cc-collection
+
+Download the latest version from npm and install to ~/.claude/.
+
+## Instructions
+
+Run the npx command to fetch and install the latest version:
+
+```bash
+npx davenov-cc@latest
+```
+
+The `@latest` tag ensures npm fetches the newest version, bypassing any cached versions.
+
+Report the results to the user.

package/install.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const readline = require("readline");
+
+const CLAUDE_DIR = path.join(os.homedir(), ".claude");
+const SOURCE_DIR = __dirname;
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const AUTO_OVERRIDE = args.includes("--auto-override");
+
+// Directories to install
+const CUSTOMIZATION_DIRS = ["commands", "skills"];
+
+function createReadlineInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+async function prompt(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, resolve);
+  });
+}
+
+function copyRecursive(src, dest) {
+  const stats = fs.statSync(src);
+
+  if (stats.isDirectory()) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src);
+    for (const entry of entries) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+function countFiles(dir) {
+  let count = 0;
+  if (!fs.existsSync(dir)) return 0;
+
+  const entries = fs.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    const stats = fs.statSync(fullPath);
+    if (stats.isDirectory()) {
+      count += countFiles(fullPath);
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+
+async function main() {
+  console.log("\n📦 Claude Code Customizations Installer\n");
+  console.log(`Source: ${SOURCE_DIR}`);
+  console.log(`Target: ${CLAUDE_DIR}\n`);
+
+  // Check what we have to install
+  const available = CUSTOMIZATION_DIRS.filter((dir) =>
+    fs.existsSync(path.join(SOURCE_DIR, dir))
+  );
+
+  if (available.length === 0) {
+    console.log("No customizations found to install.");
+    process.exit(0);
+  }
+
+  console.log("Available customizations:");
+  for (const dir of available) {
+    const srcPath = path.join(SOURCE_DIR, dir);
+    const fileCount = countFiles(srcPath);
+    console.log(`  - ${dir}/ (${fileCount} files)`);
+  }
+  console.log();
+
+  // Check for existing files
+  const existing = available.filter((dir) =>
+    fs.existsSync(path.join(CLAUDE_DIR, dir))
+  );
+
+  const rl = createReadlineInterface();
+
+  if (existing.length > 0) {
+    console.log("⚠️  The following directories already exist:");
+    for (const dir of existing) {
+      console.log(`  - ${path.join(CLAUDE_DIR, dir)}`);
+    }
+    console.log();
+
+    if (AUTO_OVERRIDE) {
+      console.log("Auto-override enabled, proceeding...");
+    } else {
+      const answer = await prompt(
+        rl,
+        "Do you want to overwrite existing files? (y/N): "
+      );
+
+      if (answer.toLowerCase() !== "y") {
+        console.log("\nInstallation cancelled.");
+        rl.close();
+        process.exit(0);
+      }
+    }
+  }
+
+  // Ensure .claude directory exists
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    console.log(`Created ${CLAUDE_DIR}`);
+  }
+
+  // Install each directory
+  console.log("\nInstalling...\n");
+
+  for (const dir of available) {
+    const srcPath = path.join(SOURCE_DIR, dir);
+    const destPath = path.join(CLAUDE_DIR, dir);
+
+    console.log(`  ${dir}/`);
+    copyRecursive(srcPath, destPath);
+  }
+
+  console.log("\n✅ Installation complete!\n");
+  console.log("Your customizations are now available in Claude Code.");
+
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "davenov-cc",
+  "version": "1.0.0",
+  "description": "Claude Code customizations - skills and slash commands for enhanced AI-assisted development",
+  "bin": {
+    "davenov-cc": "./bin/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaladivo/davenov-cc-collection.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "skills",
+    "commands",
+    "customizations"
+  ],
+  "author": "kaladivo",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kaladivo/davenov-cc-collection/issues"
+  },
+  "homepage": "https://github.com/kaladivo/davenov-cc-collection#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "commands/",
+    "skills/",
+    "install.js"
+  ]
+}