100xprism 2.3.1

package/modules/test/references/e2e-patterns.md

@@ -0,0 +1,294 @@
+# E2E Test Patterns
+
+Reference patterns used by the `/test` workflow. All patterns follow the real-over-mocked principle: create real users via the API, run against a real Docker stack, verify persistence in the DB.
+
+---
+
+## Auth Fixture
+
+**`e2e/fixtures/api.ts`** — create test users and get tokens via real API calls:
+
+```typescript
+import { APIRequestContext } from '@playwright/test'
+
+export async function createTestUser(
+  request: APIRequestContext,
+  overrides?: Partial<{ email: string; password: string; name: string }>
+) {
+  const email = overrides?.email ?? `test-${Date.now()}@example.com`
+  const password = overrides?.password ?? 'TestPass123!'
+  const name = overrides?.name ?? 'Test User'
+  const res = await request.post('/api/auth/register', { data: { email, password, name } })
+  if (!res.ok()) throw new Error(`User creation failed: ${await res.text()}`)
+  return { email, password, name, id: (await res.json()).id }
+}
+
+export async function getAuthToken(
+  request: APIRequestContext,
+  email: string,
+  password: string
+): Promise<string> {
+  const res = await request.post('/api/auth/login', { data: { email, password } })
+  if (!res.ok()) throw new Error(`Login failed: ${await res.text()}`)
+  return (await res.json()).token
+}
+```
+
+**`e2e/fixtures/auth.ts`** — real auth fixture (actual login, not mocked JWT):
+
+```typescript
+import { test as base } from '@playwright/test'
+import { createTestUser, getAuthToken } from './api'
+
+type AuthFixtures = {
+  authToken: string
+  authenticatedPage: import('@playwright/test').Page
+  testUser: { email: string; password: string; name: string; id: string }
+}
+
+export const test = base.extend<AuthFixtures>({
+  testUser: async ({ request }, use) => {
+    const user = await createTestUser(request)
+    await use(user)
+  },
+  authToken: async ({ request, testUser }, use) => {
+    const token = await getAuthToken(request, testUser.email, testUser.password)
+    await use(token)
+  },
+  authenticatedPage: async ({ page, authToken }, use) => {
+    await page.goto('/')
+    await page.evaluate((token) => localStorage.setItem('authToken', token), authToken)
+    await page.reload()
+    await use(page)
+  },
+})
+
+export { expect } from '@playwright/test'
+```
+
+---
+
+## Smoke Tests
+
+Run these first — fast gate before the full suite.
+
+**`e2e/smoke/health.spec.ts`**:
+
+```typescript
+import { test, expect } from '@playwright/test'
+
+test('API /health returns 200', async ({ request }) => {
+  const res = await request.get('/health')
+  expect(res.status()).toBe(200)
+  expect((await res.json()).status).toBe('ok')
+})
+
+test('API /health/db confirms DB connection', async ({ request }) => {
+  const res = await request.get('/health/db')
+  expect(res.status()).toBe(200)
+  expect((await res.json()).database).toBe('connected')
+})
+
+test('frontend loads without JS errors', async ({ page }) => {
+  const errors: string[] = []
+  page.on('console', (msg) => { if (msg.type() === 'error') errors.push(msg.text()) })
+  await page.goto('/')
+  await expect(page).toHaveTitle(/your app name/i)
+  expect(errors).toHaveLength(0)
+})
+
+test('login page renders', async ({ page }) => {
+  await page.goto('/login')
+  await expect(page.getByRole('button', { name: /sign in/i })).toBeVisible()
+})
+```
+
+---
+
+## Auth Flow Tests
+
+**`e2e/auth/login.spec.ts`**:
+
+```typescript
+import { test, expect } from '../fixtures/auth'
+
+test('user can register and land on dashboard', async ({ page, request }) => {
+  const email = `e2e-${Date.now()}@example.com`
+  const password = 'TestPass123!'
+
+  await page.goto('/register')
+  await page.getByLabel('Email').fill(email)
+  await page.getByLabel('Password').fill(password)
+  await page.getByRole('button', { name: /create account/i }).click()
+
+  await expect(page).toHaveURL(/\/dashboard/)
+  await expect(page.getByText(/welcome/i)).toBeVisible()
+
+  // Confirm user exists in DB
+  const token = await (await request.post('/api/auth/login', { data: { email, password } })).json()
+  expect(token.token).toBeTruthy()
+})
+
+test('user can log in with real credentials', async ({ page, testUser }) => {
+  await page.goto('/login')
+  await page.getByLabel('Email').fill(testUser.email)
+  await page.getByLabel('Password').fill(testUser.password)
+  await page.getByRole('button', { name: /sign in/i }).click()
+
+  await expect(page).toHaveURL(/\/dashboard/)
+  await expect(page.getByText(testUser.name)).toBeVisible()
+})
+
+test('invalid credentials show error', async ({ page }) => {
+  await page.goto('/login')
+  await page.getByLabel('Email').fill('nobody@example.com')
+  await page.getByLabel('Password').fill('wrongpassword')
+  await page.getByRole('button', { name: /sign in/i }).click()
+
+  await expect(page.getByRole('alert')).toContainText(/invalid/i)
+  await expect(page).toHaveURL(/\/login/)
+})
+```
+
+---
+
+## CRUD Tests
+
+Browser creates entity → API confirms it persisted. No mock return values.
+
+**`e2e/[entity]/crud.spec.ts`** (adapt to your entity):
+
+```typescript
+import { test, expect } from '../fixtures/auth'
+
+test('create entity via UI and verify persistence', async ({
+  authenticatedPage: page, request, authToken,
+}) => {
+  await page.goto('/dashboard/entities')
+  await page.getByRole('button', { name: /new/i }).click()
+
+  const name = `Test Entity ${Date.now()}`
+  await page.getByLabel('Name').fill(name)
+  await page.getByRole('button', { name: /create/i }).click()
+
+  await expect(page.getByText(name)).toBeVisible()
+
+  // Confirm it actually persisted — not just UI state
+  const res = await request.get('/api/entities', {
+    headers: { Authorization: `Bearer ${authToken}` },
+  })
+  const items = await res.json()
+  expect(items.find((i: { name: string }) => i.name === name)).toBeDefined()
+})
+
+test('edit entity updates DB record', async ({
+  authenticatedPage: page, request, authToken,
+}) => {
+  const createRes = await request.post('/api/entities', {
+    headers: { Authorization: `Bearer ${authToken}` },
+    data: { name: 'Original Name' },
+  })
+  const item = await createRes.json()
+
+  await page.goto(`/dashboard/entities/${item.id}`)
+  await page.getByLabel('Name').clear()
+  await page.getByLabel('Name').fill('Updated Name')
+  await page.getByRole('button', { name: /save/i }).click()
+
+  await expect(page.getByText('Updated Name')).toBeVisible()
+
+  const fetchRes = await request.get(`/api/entities/${item.id}`, {
+    headers: { Authorization: `Bearer ${authToken}` },
+  })
+  expect((await fetchRes.json()).name).toBe('Updated Name')
+})
+
+test('delete entity removes from DB', async ({
+  authenticatedPage: page, request, authToken,
+}) => {
+  const createRes = await request.post('/api/entities', {
+    headers: { Authorization: `Bearer ${authToken}` },
+    data: { name: 'To Be Deleted' },
+  })
+  const item = await createRes.json()
+
+  await page.goto('/dashboard/entities')
+  await page.getByTestId(`entity-row-${item.id}`).getByRole('button', { name: /delete/i }).click()
+  await page.getByRole('button', { name: /confirm/i }).click()
+
+  await expect(page.getByText('To Be Deleted')).not.toBeVisible()
+
+  const fetchRes = await request.get(`/api/entities/${item.id}`, {
+    headers: { Authorization: `Bearer ${authToken}` },
+  })
+  expect(fetchRes.status()).toBe(404)
+})
+```
+
+---
+
+## Running E2E
+
+**Start full stack:**
+
+```bash
+if [ -f docker-compose.e2e.yml ] && [ -f docker-compose.yml ]; then
+  COMPOSE_CMD="docker compose -f docker-compose.yml -f docker-compose.e2e.yml"
+elif [ -f docker-compose.test.yml ]; then
+  COMPOSE_CMD="docker compose -f docker-compose.test.yml"
+else
+  COMPOSE_CMD="docker compose"
+fi
+$COMPOSE_CMD up -d --build --wait
+```
+
+**Wait for app health:**
+
+```bash
+for i in $(seq 1 12); do
+  curl -sf http://localhost:3000/health 2>/dev/null && break ||
+  curl -sf http://localhost:8000/health 2>/dev/null && break ||
+  { echo "Attempt $i/12 — waiting..."; sleep 5; }
+done
+```
+
+**Run smoke first, then full suite:**
+
+```bash
+# 1. Smoke gate (fast)
+npx playwright test e2e/smoke/ --config=playwright.e2e.config.ts
+
+# 2. Full suite
+npx playwright test --config=playwright.e2e.config.ts
+
+# Against staging or prod
+BASE_URL=https://staging.example.com npx playwright test --config=playwright.e2e.config.ts
+```
+
+**Python projects:**
+
+```bash
+BASE_URL="${E2E_BASE_URL:-http://localhost:8000}" \
+  ./venv/bin/pytest tests/e2e/ -v --tb=short
+```
+
+**Teardown:**
+
+```bash
+$COMPOSE_CMD down -v 2>/dev/null || true
+```
+
+---
+
+## What to Mock (and What Not To)
+
+```python
+# ✅ Mock this — genuinely unreachable locally
+monkeypatch.setattr("stripe.PaymentIntent.create", AsyncMock(return_value={"id": "pi_test"}))
+monkeypatch.setattr("sendgrid.send", AsyncMock(return_value=None))
+
+# ❌ Never mock this — use a real Docker DB instead
+monkeypatch.setattr("db.session.add", MagicMock())     # masks constraint violations
+monkeypatch.setattr("db.session.commit", MagicMock())  # masks transaction failures
+monkeypatch.setattr("redis_client.get", MagicMock())   # masks TTL/serialisation bugs
+```

package/modules/update-claude-md/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: update-claude-md
+description: After any correction from the user, update CLAUDE.md with a rule to prevent the same mistake from recurring. Use when the user corrects your behavior or says "don't do that again". Ruthlessly iterate CLAUDE.md until mistake rate measurably drops.
+category: engineering
+tier: core
+slash_command: /update-claude
+allowed-tools: Read Edit Write
+model: haiku
+---
+
+# Update-Claude — CLAUDE.md Rule Writer
+
+After any correction, update CLAUDE.md with a rule to prevent the same mistake recurring.
+
+## How to use
+- `/update-claude` — after a correction, write a rule to CLAUDE.md
+
+---
+
+## Phase 1 — Identify the pattern
+
+What went wrong? What should have been done instead? Be specific — one clear pattern, not a vague note.
+
+---
+
+## Phase 2 — Write a rule
+
+Formulate as a clear, actionable rule:
+```
+- [Rule]: [What to do / not to do]. Why: [brief context].
+```
+
+Short rules stick. Long paragraphs get ignored.
+
+---
+
+## Phase 3 — Update CLAUDE.md
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+INSTRUCTION_FILE=$(for f in CLAUDE.md AGENTS.md .cursorrules .windsurfrules .github/copilot-instructions.md GEMINI.md; do [ -f "$PROJECT_ROOT/$f" ] && echo "$PROJECT_ROOT/$f" && break; done)
+```
+
+Append the rule under a `## Rules` or `## Corrections` section in the project's instruction file. If no instruction file exists, create `CLAUDE.md` in the project root.
+
+---
+
+## Phase 4 — Confirm
+
+Tell the user: "Updated [file] with: [rule summary]"
+
+If the rule isn't reducing mistakes after 2–3 sessions: rewrite it — be more specific or more prominent.

package/modules/visual-system-architect/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: visual-system-architect
+description: Act as a Global Design Director to produce a complete design system — color palette, typography scale, 8px grid, 30+ components, responsive patterns, animations, and WCAG AA accessibility. Exports design tokens (JSON), CSS variables, and Figma-ready docs. Use when building a brand's visual foundation for Figma Make or a design handoff.
+category: design
+tier: on-demand
+allowed-tools: Read Write
+---
+
+You are a Global Design Director tasked with building a scalable design system for the described brand.
+
+## Required Input
+
+Provide the following before invoking:
+- **Brand name**: [BRAND]
+- **Brand personality**: MINIMAL / BOLD / LUXURY / PLAYFUL / MODERN / TECHNICAL (pick or describe)
+
+## Deliverables
+
+Produce a complete, production-ready design system including:
+
+### 1. Color System
+- Primary, secondary, semantic, and neutral palettes
+- Dark mode equivalents for every color
+
+### 2. Typography Framework
+- 9-step type scale with font pairing rationale
+
+### 3. Spatial System
+- 8px grid foundation with spacing tokens
+
+### 4. Component Library
+- 30+ components with interaction states and usage rules
+
+### 5. Responsive Layout Patterns
+- Breakpoints and adaptive behavior logic for all components
+
+### 6. Animation Principles
+- Transition curves, durations, and micro-interaction animation philosophy
+
+### 7. Accessibility Standards
+- WCAG AA compliance guidance and contrast ratios throughout
+
+## Export Formats
+
+Deliver in three formats:
+
+1. **Design tokens** — JSON structure
+2. **CSS variable declarations**
+3. **Figma-ready component documentation**
+
+## Output Goal
+
+This output will power the visual foundation inside Figma Make. Format all specs for direct handoff — no further interpretation required.

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "100xprism",
+  "version": "2.3.1",
+  "description": "66 cross-tool modules (workflows + skills). Quality gates on every commit. Works with Claude Code, Cursor, Codex, Windsurf, Antigravity, Copilot, Gemini.",
+  "scripts": {
+    "test": "node --test",
+    "check": "node --test && python3 scripts/meta-check.py && HOME=$(mktemp -d) ./adapters/claude-code.sh"
+  },
+  "bin": {
+    "100xprism": "bin/100xprism.js",
+    "100x-dev": "bin/100xprism.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "modules/",
+    "plugins/",
+    "templates/",
+    "shell/",
+    "adapters/",
+    "get.sh",
+    "install.sh",
+    "install-project.sh",
+    "update.sh",
+    "VERSION"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude-code",
+    "cursor",
+    "codex",
+    "ai-coding",
+    "developer-workflow",
+    "slash-commands"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rajitsaha/100xprism.git"
+  },
+  "homepage": "https://github.com/rajitsaha/100xprism"
+}

package/plugins/plugins.json

@@ -0,0 +1,43 @@
+{
+  "plugins": [
+    "frontend-design@claude-plugins-official",
+    "superpowers@claude-plugins-official",
+    "playwright@claude-plugins-official",
+    "github@claude-plugins-official",
+    "security-guidance@claude-code-plugins",
+    "skill-creator@claude-plugins-official",
+    "code-simplifier@claude-plugins-official",
+    "pr-review-toolkit@claude-plugins-official",
+    "hookify@claude-plugins-official",
+    "claude-mem@thedotmack",
+    "understand-anything@understand-anything",
+    "ui-ux-pro-max@ui-ux-pro-max-skill",
+    "chrome-devtools-mcp@claude-plugins-official"
+  ],
+  "extraKnownMarketplaces": {
+    "claude-code-plugins": {
+      "source": {
+        "source": "github",
+        "repo": "anthropics/claude-code"
+      }
+    },
+    "thedotmack": {
+      "source": {
+        "source": "github",
+        "repo": "thedotmack/claude-mem"
+      }
+    },
+    "understand-anything": {
+      "source": {
+        "source": "github",
+        "repo": "Lum1104/Understand-Anything"
+      }
+    },
+    "ui-ux-pro-max-skill": {
+      "source": {
+        "source": "github",
+        "repo": "nextlevelbuilder/ui-ux-pro-max-skill"
+      }
+    }
+  }
+}

package/shell/aliases.sh

@@ -0,0 +1,24 @@
+# shellcheck shell=bash
+# 100x Dev shortcuts
+# Source this file from ~/.zshrc or ~/.bashrc:
+#   source ~/100xprism/shell/aliases.sh
+
+# Launch Claude
+alias cc='claude'
+alias ccc='claude --continue'
+
+# Setup management
+# shellcheck disable=SC2139
+alias 100xprism="node $HOME/100xprism/bin/100xprism.js"
+# shellcheck disable=SC2139
+alias 100x-update="$HOME/100xprism/update.sh"
+# shellcheck disable=SC2139
+alias 100x-check="$HOME/100xprism/update.sh --check-only"
+
+# ── Version check ─────────────────────────────────────────────────────────────
+# On shell startup: read cached update status (no network) + prompt if available.
+# Then kick off a background cache refresh for next session.
+if [[ -x "$HOME/100xprism/shell/check-update.sh" ]]; then
+  bash "$HOME/100xprism/shell/check-update.sh" --notify
+  ("$HOME/100xprism/shell/check-update.sh" --silent &) 2>/dev/null
+fi