rex-claude 2.1.0 → 3.0.0

package/dist/setup-AO3MW46W.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+// src/setup.ts
+import { execSync } from "child_process";
+import { platform, totalmem, homedir } from "os";
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m"
+};
+function ok(msg) {
+  console.log(`  ${COLORS.green}\u2713${COLORS.reset} ${msg}`);
+}
+function info(msg) {
+  console.log(`  ${COLORS.cyan}\u2139${COLORS.reset} ${msg}`);
+}
+function fail(msg) {
+  console.log(`  ${COLORS.red}\u2717${COLORS.reset} ${msg}`);
+}
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+async function isOllamaInstalled() {
+  try {
+    execSync("which ollama", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isOllamaRunning() {
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function getInstalledModels() {
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/tags`);
+    const data = await res.json();
+    return data.models.map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+function pullModel(model) {
+  console.log(`  ${COLORS.dim}Pulling ${model}...${COLORS.reset}`);
+  try {
+    execSync(`ollama pull ${model}`, { stdio: "inherit" });
+    ok(`${model} installed`);
+  } catch {
+    fail(`Failed to pull ${model}`);
+  }
+}
+async function testEmbed() {
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "nomic-embed-text", input: "test embedding" })
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function testGenerate(model) {
+  try {
+    const res = await fetch(`${OLLAMA_URL}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, prompt: 'Say "ok" in one word.', stream: false })
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`  ${COLORS.cyan}?${COLORS.reset} ${question} `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function setupTelegram() {
+  console.log(`
+  ${COLORS.bold}Telegram Gateway${COLORS.reset}`);
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+  } catch {
+  }
+  if (!settings.env) settings.env = {};
+  const existingToken = settings.env.REX_TELEGRAM_BOT_TOKEN;
+  const existingChat = settings.env.REX_TELEGRAM_CHAT_ID;
+  if (existingToken && existingChat) {
+    try {
+      const res = await fetch(`https://api.telegram.org/bot${existingToken}/sendMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: existingChat, text: "\u{1F514} REX Setup \u2014 Telegram gateway verified", parse_mode: "Markdown" })
+      });
+      if (res.ok) {
+        ok("Telegram gateway already configured and working");
+        return;
+      }
+    } catch {
+    }
+    info("Existing Telegram config found but not working \u2014 reconfiguring");
+  }
+  const botToken = await prompt("Telegram Bot Token (from @BotFather):");
+  if (!botToken) {
+    info("Skipped Telegram setup");
+    return;
+  }
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${botToken}/getMe`);
+    const data = await res.json();
+    if (!data.ok) {
+      fail("Invalid bot token");
+      return;
+    }
+    ok(`Bot: @${data.result?.username}`);
+  } catch {
+    fail("Could not validate bot token");
+    return;
+  }
+  console.log(`
+  ${COLORS.dim}Send /start to your bot on Telegram, then press Enter...${COLORS.reset}`);
+  await prompt("Press Enter when done");
+  let chatId = "";
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${botToken}/getUpdates`);
+    const data = await res.json();
+    const msg = data.result?.find((u) => u.message);
+    if (msg?.message) {
+      chatId = String(msg.message.chat.id);
+      ok(`Chat ID: ${chatId} (from @${msg.message.from?.username ?? "?"})`);
+    }
+  } catch {
+  }
+  if (!chatId) {
+    chatId = await prompt("Chat ID (could not auto-detect):");
+  }
+  if (!chatId) {
+    fail("No chat ID \u2014 Telegram setup aborted");
+    return;
+  }
+  settings.env.REX_TELEGRAM_BOT_TOKEN = botToken;
+  settings.env.REX_TELEGRAM_CHAT_ID = chatId;
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  ok("Telegram credentials saved to settings.json");
+  try {
+    await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text: "\u2705 *REX Setup Complete*\nTelegram gateway is active.", parse_mode: "Markdown" })
+    });
+    ok("Test message sent \u2014 check Telegram!");
+  } catch {
+    fail("Could not send test message");
+  }
+}
+async function setup() {
+  const line = "\u2550".repeat(45);
+  console.log(`
+${line}`);
+  console.log(`${COLORS.bold}        REX SETUP \u2014 Full Configuration${COLORS.reset}`);
+  console.log(`${line}
+`);
+  const ramGB = Math.round(totalmem() / 1024 ** 3);
+  const os = platform();
+  info(`System: ${os}, ${ramGB}GB RAM`);
+  if (!await isOllamaInstalled()) {
+    fail("Ollama not installed");
+    console.log(`
+  Install: ${COLORS.cyan}https://ollama.com/download${COLORS.reset}`);
+    if (os === "darwin") {
+      info("Opening download page...");
+      try {
+        execSync("open https://ollama.com/download", { stdio: "ignore" });
+      } catch {
+      }
+    }
+    return;
+  }
+  ok("Ollama installed");
+  if (!await isOllamaRunning()) {
+    info("Starting Ollama...");
+    try {
+      execSync("ollama serve &", { stdio: "ignore" });
+      await new Promise((r) => setTimeout(r, 3e3));
+      if (await isOllamaRunning()) {
+        ok("Ollama started");
+      } else {
+        fail("Could not start Ollama \u2014 start manually: ollama serve");
+        return;
+      }
+    } catch {
+      fail("Could not start Ollama \u2014 start manually: ollama serve");
+      return;
+    }
+  } else {
+    ok("Ollama running");
+  }
+  const models = await getInstalledModels();
+  if (models.some((m) => m.includes("nomic-embed-text"))) {
+    ok("nomic-embed-text already installed");
+  } else {
+    pullModel("nomic-embed-text");
+  }
+  const reasoningModel = ramGB >= 16 ? "qwen3.5:9b" : "qwen3.5:4b";
+  info(`Selected reasoning model: ${reasoningModel} (${ramGB}GB RAM)`);
+  if (models.some((m) => m.includes(reasoningModel.split(":")[0]))) {
+    ok(`${reasoningModel} already installed`);
+  } else {
+    pullModel(reasoningModel);
+  }
+  console.log(`
+  ${COLORS.dim}Testing...${COLORS.reset}`);
+  const embedOk = await testEmbed();
+  const genOk = await testGenerate(reasoningModel);
+  if (embedOk) ok("Embedding test passed");
+  else fail("Embedding test failed");
+  if (genOk) ok("Generation test passed");
+  else fail("Generation test failed");
+  await setupTelegram();
+  console.log(`
+${COLORS.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${COLORS.reset}`);
+  if (embedOk && genOk) {
+    console.log(`
+  ${COLORS.green}${COLORS.bold}Setup complete!${COLORS.reset} REX is fully configured.`);
+  } else {
+    console.log(`
+  ${COLORS.yellow}Setup partial.${COLORS.reset} Some tests failed \u2014 check Ollama logs.`);
+  }
+  console.log();
+}
+export {
+  setup
+};

package/dist/skills/build-validate/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: build-validate
+description: Verify code changes compile, pass tests, and work correctly. Runs build, lint, tests, dev server checks. Reports without modifying code.
+---
+
+# Build Validation
+
+Verify the current project state:
+
+1. Run build command (`npm run build` or equivalent)
+2. Run linter if configured
+3. Run test suite if exists
+4. Start dev server, verify it loads (curl for 200)
+5. For UI changes, take a screenshot
+
+Report each step as PASS/FAIL with details. NEVER modify code — only report.
+
+## Auto-Learn
+
+If any step FAILS, call `rex_learn` MCP tool:
+- category: `"lesson"`
+- fact: the error message + root cause + fix applied (e.g. "Next.js build fails with X when Y — fix: Z")
+- This builds a knowledge base of project-specific build issues

package/dist/skills/code-review/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: code-review
+description: Thorough code review of staged/changed files. Checks logic errors, security, performance, missing states, TypeScript strictness.
+---
+
+# Code Review
+
+Review all changed files (`git diff`):
+
+1. Logic errors and edge cases
+2. Security vulnerabilities (OWASP top 10)
+3. Performance (N+1 queries, unbounded loops, missing indexes)
+4. Missing error handling, loading/empty/error states
+5. TypeScript strictness (no `any`, no `@ts-ignore` without justification)
+6. Consistency with existing codebase patterns
+
+Rate findings: **critical** / **warning** / **suggestion**. Provide fix snippets.
+Never suggest modifying tests to pass. Focus bugs > security > style.
+
+## Auto-Learn
+
+After completing the review, call `rex_learn` MCP tool for each notable finding:
+- category: `"pattern"` for codebase patterns, `"lesson"` for bugs/anti-patterns
+- fact: concise description of the pattern found and why it matters
+- Only learn findings rated **critical** or recurring patterns — skip trivial suggestions

package/dist/skills/context-loader/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: context-loader
+description: Load relevant documentation and project context before starting work. Reads local docs cache, project CLAUDE.md, and REX memory. Use at session start or project switch.
+---
+
+# Context Loader
+
+Load context for: $ARGUMENTS (project path or framework name)
+
+## If project path given:
+1. Read project's `CLAUDE.md` if exists
+2. Read `package.json` / `composer.json` / `pubspec.yaml` to detect stack
+3. Call `rex_context(project_path)` for past session insights
+4. For each framework detected, read `~/.claude/docs/{framework}.md` if exists
+5. Report: stack detected, relevant docs loaded, past context found
+
+## If framework name given:
+1. Check `~/.claude/docs/{framework}.md` — if exists, read it
+2. If not exists, fetch via Context7 and save key patterns to `~/.claude/docs/{framework}.md`
+3. Report: doc loaded/created, key patterns summarized
+
+## Rules
+- NEVER load docs that aren't relevant to the current task
+- Always check local cache before fetching from network
+- Keep doc files under 100 lines — patterns and gotchas only, not full API reference

package/dist/skills/debug-assist/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: debug-assist
+description: Systematic debugging. Reads error, searches REX memory for past solutions, checks docs, identifies root cause. Use when stuck on an error.
+---
+
+# Debug Assist
+
+Debug: $ARGUMENTS (paste the error message or describe the issue)
+
+## Process
+1. **Parse the error**: extract file, line, error type, stack trace
+2. **Check REX memory**: `rex_search("error message keywords")` for past solutions
+3. **Check local docs**: read `~/.claude/docs/{framework}.md` for known gotchas
+4. **Search codebase**: find the failing code, read surrounding context
+5. **Identify root cause**: not the symptom — what ACTUALLY caused it
+6. **Propose fix**: with code snippet and explanation
+
+## Anti-patterns (NEVER do these)
+- Never suppress the error without understanding it
+- Never delete a test to make it pass
+- Never add `@ts-ignore` or `eslint-disable` as a fix
+- Never retry the same approach more than twice — try a different angle
+
+## After fixing
+- Save the pattern to REX: `rex_learn("Error X was caused by Y, fix is Z", "debug")`
+- Update `~/.claude/docs/{framework}.md` if it's a framework gotcha

package/dist/skills/deploy-checklist/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: deploy-checklist
+description: Pre-deployment checklist. Use when user says "deploy", "push to prod", "push to beta", "ship it", or before any deployment. Runs verification steps before allowing deploy.
+disable-model-invocation: true
+---
+
+# Deploy Checklist
+
+Run this checklist BEFORE any deployment. $ARGUMENTS can specify the target (beta/prod).
+
+## Pre-Deploy Verification
+
+1. **Check git status**:
+   - All changes committed? No uncommitted work?
+   - On the correct branch?
+   - Branch is up to date with remote?
+
+2. **Run tests** (if test suite exists):
+   ```bash
+   # Detect and run project tests
+   # PHP: composer test or vendor/bin/phpunit
+   # Node/Angular: npm test
+   # Flutter: flutter test
+   # Python: pytest
+   ```
+
+3. **Run linter/formatter** (if configured):
+   ```bash
+   # Detect and run linter
+   # PHP: composer lint or vendor/bin/phpcs
+   # Node: npm run lint
+   # Flutter: flutter analyze
+   ```
+
+4. **Build check**:
+   - Run production build to catch compile errors
+   - Verify build output exists and looks correct
+
+5. **Environment check**:
+   - Verify environment config points to the correct target (beta vs prod)
+   - NEVER deploy with local/dev config pointing to wrong DB or API
+   - Check for hardcoded localhost URLs
+
+6. **PR status** (if deploying from a PR):
+   - All CI checks passing?
+   - Gemini Code Assist review: any critical issues?
+   - GitHub Copilot review: any critical issues?
+
+## Deploy Decision
+
+- If ANY check fails: STOP and report to user
+- If all checks pass: proceed with deploy and confirm target with user
+
+IMPORTANT: Always ask "beta or prod?" if not specified. Never assume prod.
+
+## Auto-Learn
+
+If any deploy issue is found, call `rex_learn` MCP tool:
+- category: `"lesson"`
+- fact: the deploy issue + environment + fix (e.g. "Cloudflare deploy failed: missing wrangler.toml env binding for PROD")
+- Helps prevent repeating the same deploy mistakes

package/dist/skills/dstudio-design-system/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: dstudio-design-system
+description: Load the dstudio-ui design system context — tokens, components, patterns, and import guide. Use when building UI with @dstudio/ui components or design tokens.
+user-invocable: true
+---
+
+# dstudio-ui Design System
+
+You are working with the **@dstudio/ui** design system. Use this reference for all UI implementation.
+
+## Architecture
+
+- **Repo**: `/Users/keiy/Documents/Developer/dstudio-ui`
+- **Package**: `@dstudio/ui` — exported from `src/index.ts`
+- **Stack**: Next.js 16, Tailwind v4, Framer Motion (`motion/react`), Storybook v8, pnpm
+- **`@` alias** maps to `src/` (NOT project root)
+
+## Using in Another Project
+
+```json
+// package.json
+"@dstudio/ui": "file:../dstudio-ui"
+```
+
+Then `pnpm install` and import:
+
+```tsx
+import { DSButton, MagicCard, KanbanBoard } from "@dstudio/ui"
+```
+
+The consumer project **must** share the same Tailwind v4 setup with CSS vars from `globals.css`. Tokens are CSS variables, not bundled.
+
+## Design Tokens (Style Dictionary v4)
+
+- **Format**: W3C DTCG `{ "$value": "...", "$type": "color" }`
+- **Token files**: `tokens/core/*.json` + `tokens/semantic/colors.json`
+- **Build**: `pnpm build:tokens` → `build/css/`, `build/tailwind/`, `build/figma/`, `build/js/`
+- **Config**: `sd.config.ts` at repo root
+
+### Key Semantic Colors
+
+| Token | Value | CSS var |
+|-------|-------|---------|
+| background | #000000 | `--color-background` |
+| foreground | #ffffff | `--color-foreground` |
+| card | #080808 | `--color-card` |
+| primary | #18181b | `--color-primary` |
+| secondary | #f4f4f5 | `--color-secondary` |
+| muted | #1a1a1a | `--color-muted` |
+| border | #e4e4e7 | `--color-border` |
+| destructive | #ef4444 | `--color-destructive` |
+
+### Using tokens in Tailwind
+
+```tsx
+// Tokens live in @theme {} block → Tailwind v4 auto-generates utilities
+className="bg-background text-foreground border-border"
+className="text-gray-400 bg-dark-100"
+```
+
+### Adding a new token
+
+1. Add to `tokens/core/*.json` or `tokens/semantic/colors.json`
+2. `pnpm build:tokens`
+3. Copy new var into `src/styles/globals.css` inside `@theme {}` block
+4. Commit `build/` directory + `globals.css`
+
+## Available Components
+
+### D-Studio branded
+GradientButton, GlassBadge, SmallButton, MultiLayerCard, SlightSeparator, DSButton, SquaredBadge
+
+### Base UI (shadcn-style)
+Badge, Button, Card, Input, Accordion, Dialog, Tabs, OrbitingCircles, Skeleton, Textarea, DropdownMenu
+
+### Motion
+BlurFade, InfiniteSlider, TextEffect, Tilt, GlowEffect, Magnetic, MagicCard, BorderTrail, TextScramble, SpinningText, TextReveal, Cursor
+
+### Bits
+StarBorder, GradualBlur, StackingCards
+
+### PM (Project Management)
+StatusBadge, AvatarStack, BoardTable, KanbanBoard, GanttChart, TimelineCalendar, DatePicker, StatusSelector, Notepad, NeonGlow, AnimatedBlob, PrioritySlider
+
+### AI
+AskAiButton, SuggestionChips
+
+### Contact
+ContactForm, MultiStateButton
+
+### Shared
+ScrambleRevealText, ProgressiveScrambleText, AnimatedSection
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/index.ts` | Main package export |
+| `sd.config.ts` | Style Dictionary config |
+| `tokens/core/colors.json` | Primitive color palette |
+| `tokens/semantic/colors.json` | Semantic color aliases |
+| `src/styles/globals.css` | `@theme` block (must be inline) |
+| `src/app/components/page.tsx` | Components showcase page |
+| `src/app/docs/components/component-data.ts` | Docs prop tables |
+
+## Gotchas
+
+- **`@theme {}` must be inline** in `globals.css` — `@import` of a file containing `@theme` breaks Vite/Storybook
+- **`build/` directory is committed** (generated token outputs)
+- **`Transition` type** import must come from `motion/react`
+- **Framer Motion** — use `motion/react` not `framer-motion` for imports
+- Nav variants: `floating-nav-landing.tsx` (next-intl), `floating-nav.tsx` (no i18n)
+
+## When building UI with this system
+
+1. Read the relevant component source in `dstudio-ui/src/` before using it
+2. Follow existing Tailwind v4 patterns (CSS vars, not hardcoded colors)
+3. Use `motion/react` for all animations
+4. Check `src/index.ts` to see what's exported before importing
+5. Run `pnpm build` in the consumer project to verify

package/dist/skills/figma-workflow/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: figma-workflow
+description: Implement UI from Figma designs using get_design_context, mapping to dstudio-ui components and project design tokens. Use when given a Figma URL or node ID.
+---
+
+# Figma to Code Workflow
+
+Use this skill when implementing UI from Figma designs.
+
+## Process
+1. Call `get_design_context` with the Figma node ID and file key
+2. Review the returned code, screenshot, and metadata
+3. Map to existing dstudio-ui components — NEVER recreate what already exists
+4. Extract design tokens (colors, spacing, typography) and map to project tokens
+5. Adapt the reference code to the project's stack and conventions
+6. Use Code Connect to link Figma components ↔ codebase components
+
+## Rules
+- Always check dstudio-ui for existing components first
+- Use project's design tokens, not raw hex values
+- Responsive: mobile-first approach
+- Accessibility: proper ARIA labels, semantic HTML
+- Loading/empty/error states for dynamic content

package/dist/skills/fix-issue/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: fix-issue
+description: Fix a GitHub issue end-to-end. Use when user says "/fix-issue 123" or "fix issue #123".
+disable-model-invocation: true
+---
+
+# Fix GitHub Issue
+
+Analyze and fix the GitHub issue: $ARGUMENTS
+
+1. **Get issue details**:
+   ```bash
+   gh issue view $ARGUMENTS
+   ```
+
+2. **Understand the problem**:
+   - Read the issue description, labels, and comments
+   - Identify the affected area of the codebase
+   - Search for relevant files using Grep/Glob
+
+3. **Create a feature branch**:
+   ```bash
+   gh issue view $ARGUMENTS --json title -q .title
+   # Branch name: fix/issue-NUMBER-short-description
+   git checkout -b fix/issue-$ARGUMENTS-<short-description>
+   ```
+
+4. **Implement the fix**:
+   - Read relevant code before modifying
+   - Follow existing patterns in the codebase
+   - Make minimal, focused changes
+
+5. **Verify the fix**:
+   - Run tests if they exist
+   - Run linter if configured
+   - Build the project to check for errors
+
+6. **Commit and create PR**:
+   - Commit with message referencing the issue: `fix: <description> (closes #$ARGUMENTS)`
+   - Push branch and create PR linking to the issue
+   - Wait for Gemini/Copilot reviews
+
+7. **Report to user**: show what was changed and ask for review

package/dist/skills/new-rule/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: new-rule
+description: Create a new rule in ~/.claude/rules/ when a recurring error or anti-pattern is identified. Implements "Mistakes become rules" automatically.
+---
+
+# New Rule
+
+When an error or anti-pattern has been encountered multiple times (3+), create a permanent rule.
+
+1. **Identify the pattern**: What went wrong? What's the root cause?
+2. **Check existing rules**: Read `~/.claude/rules/` — does a similar rule already exist?
+3. **Write the rule**:
+   - File: `~/.claude/rules/{topic}.md` (new or append to existing)
+   - Format: `JAMAIS X → TOUJOURS Y à la place` (every prohibition MUST have an alternative)
+   - Include a concrete code example (good vs bad)
+4. **Memorize**: Call `rex_learn` with category `"lesson"` and the rule summary
+5. **Report**: Tell the user what rule was created and why
+
+Rules must be actionable, not vague. "Don't do X" is insufficient — always specify what to do instead.

package/dist/skills/notify/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: notify
+description: Send a Telegram notification to Kevin. Use when user says "/notify", "notify me", "send telegram", or at end of important tasks. Arguments become the message body.
+user_invocable: true
+---
+
+# Notify via Telegram
+
+Send a notification to Kevin's Telegram using the notify script. Zero tokens — pure shell.
+
+## Usage
+
+```bash
+bash ~/notify-telegram.sh "$ARGUMENTS"
+```
+
+If `$ARGUMENTS` is empty, auto-generate a one-line summary of what was just accomplished:
+- Project name + branch
+- What changed (brief)
+
+Example:
+```bash
+bash ~/notify-telegram.sh "PR #42 created on rex" "feat/v3 — 33 files, 1800+ lines"
+```
+
+IMPORTANT: This is a shell script call, NOT an LLM task. Do not elaborate. Just call the script.

package/dist/skills/one-shot/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: one-shot
+description: Generate a complete production-ready project in one shot. Next.js + Shadcn UI + dstudio-ui. Use for rapid prototyping and SAAS scaffolding.
+---
+
+# One-Shot Project Generator
+
+Create a complete project: $ARGUMENTS
+
+1. Read `~/.claude/docs/nextjs.md` and `~/.claude/docs/react.md` for current patterns
+2. Load dstudio-ui design system context: `/dstudio-design-system`
+3. Scaffold with: Next.js App Router, TypeScript, Tailwind v4, dstudio-ui components
+4. Include: auth scaffold, API routes with validation, DB schema, loading/empty/error states
+5. Apply all defensive engineering rules (pagination, error handling, rate limits)
+6. Setup: `package.json`, `tsconfig.json`, `.env.example`, `README.md`
+7. Run `npm install && npm run build` to verify
+
+Output a working project, not a template.