@massu/core 0.4.1 → 0.5.0

package/commands/massu-scaffold-router.md

@@ -0,0 +1,125 @@
+---
+name: massu-scaffold-router
+description: "When user wants to create a new tRPC router, API endpoint, or backend procedure — scaffolds router file, registers in root.ts, adds Zod schemas"
+allowed-tools: Bash(*), Read(*), Write(*), Edit(*), Grep(*), Glob(*)
+---
+
+# Scaffold New tRPC Router
+
+> **Shared rules apply.** Read `.claude/commands/_shared-preamble.md` before proceeding.
+
+Creates a complete tRPC router following all project database and auth patterns.
+
+## What Gets Created
+
+| File | Purpose |
+|------|---------|
+| `src/server/api/routers/[name].ts` | Router with procedures |
+| Registration in `src/server/api/root.ts` | Import + add to appRouter |
+
+## Template
+
+```typescript
+import { z } from 'zod';
+import { createTRPCRouter, protectedProcedure } from '@/server/api/trpc';
+
+export const myEntityRouter = createTRPCRouter({
+  getAll: protectedProcedure
+    .query(async ({ ctx }) => {
+      const items = await ctx.db.my_table.findMany({
+        orderBy: { created_at: 'desc' },
+      });
+      return items;
+    }),
+
+  getById: protectedProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .query(async ({ ctx, input }) => {
+      const item = await ctx.db.my_table.findUnique({
+        where: { id: input.id },
+      });
+      if (!item) throw new Error('Not found');
+      return item;
+    }),
+
+  create: protectedProcedure
+    .input(z.object({
+      name: z.string().min(1),
+      // Add fields here
+    }))
+    .mutation(async ({ ctx, input }) => {
+      return ctx.db.my_table.create({
+        data: {
+          ...input,
+          created_by: ctx.session.user.id,
+        },
+      });
+    }),
+
+  update: protectedProcedure
+    .input(z.object({
+      id: z.string().uuid(),
+      name: z.string().min(1).optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { id, ...data } = input;
+      return ctx.db.my_table.update({
+        where: { id },
+        data,
+      });
+    }),
+});
+```
+
+## 3-Step Query Pattern (for relations)
+
+```typescript
+// Step 1: Base query
+const items = await ctx.db.my_table.findMany({ where: { status: 'active' } });
+
+// Step 2: Relation query with IN
+const relatedIds = items.map(i => i.related_id).filter(Boolean);
+const related = relatedIds.length > 0
+  ? await ctx.db.related_table.findMany({ where: { id: { in: relatedIds } } })
+  : [];
+
+// Step 3: Map combine
+const relatedMap = new Map(related.map(r => [r.id, r]));
+return items.map(item => ({
+  ...item,
+  related: item.related_id ? relatedMap.get(item.related_id) : null,
+}));
+```
+
+## Registration in root.ts
+
+```typescript
+import { myEntityRouter } from './routers/my-entity';
+
+export const appRouter = createTRPCRouter({
+  // ... existing routers
+  myEntity: myEntityRouter,
+});
+```
+
+## Gotchas
+
+- **ctx.db NOT ctx.prisma** — hybrid client requires ctx.db
+- **protectedProcedure for ALL mutations** — never publicProcedure
+- **No `include:`** — hybrid DB ignores include statements; use 3-step query
+- **user_profiles NOT users** — `ctx.db.user_profiles` (auth.users not exposed)
+- **BigInt**: convert to `Number()` on return, NEVER use `BigInt()` in INSERT
+- **New tables**: add to `src/lib/db.ts` DatabaseClient BEFORE using in routers
+- **Split-commit**: NEVER add import to root.ts before router file exists
+
+## Process
+
+1. Ask user: What entity? What operations (CRUD, custom)?
+2. Run VR-SCHEMA-PRE to verify table columns exist
+3. Create router file with proper patterns
+4. Register in root.ts
+5. Run `npx tsc --noEmit` to verify types
+
+## START NOW
+
+Ask the user what entity/table the router is for and what procedures it needs.

package/commands/massu-squirrels.md

@@ -0,0 +1,101 @@
+---
+name: massu-squirrels
+description: "When user has a tangential idea mid-task that should be parked — 'squirrel this', 'park this idea', 'remind me later about'"
+allowed-tools: Bash(*), Read(*), Write(*), Edit(*), Grep(*), Glob(*)
+---
+name: massu-squirrels
+
+# Massu Squirrels: Idea Parking Lot Manager
+
+> **Shared rules apply.** Read `.claude/commands/_shared-preamble.md` before proceeding.
+
+---
+
+## Purpose
+
+Manage `.claude/session-state/squirrels.md` — a parking lot for stray ideas that come up mid-session. These are thoughts worth capturing but not worth derailing the current task for.
+
+**This is NOT a backlog.** It's a scratchpad. Ideas here are unvetted, unscoped, and may be irrelevant. The value is in not losing them.
+
+---
+
+## ARGUMENTS
+
+```
+/massu-squirrels                     # Show current squirrels list
+/massu-squirrels add [idea]          # Park a new idea
+/massu-squirrels review              # Review all ideas, grouped by age
+/massu-squirrels promote [N]         # Promote idea #N to a plan or task
+/massu-squirrels clean               # Remove stale/irrelevant ideas
+```
+
+**Arguments from command**: `{{ARGUMENTS}}`
+
+---
+
+## Actions
+
+### No argument / `review` — Show current squirrels
+
+1. Read `.claude/session-state/squirrels.md`
+2. If empty (no ideas below the divider): say "No parked squirrels." and stop
+3. If ideas exist, display them grouped by age:
+   - **Fresh** (today or yesterday)
+   - **This week** (2-7 days old)
+   - **Aging** (> 7 days — consider promoting or cleaning)
+4. Show count: "N squirrels parked (X fresh, Y aging)"
+
+### `add` — Park a new idea
+
+1. Determine the idea from `{{ARGUMENTS}}` (everything after "add")
+2. Determine current context from `session-state/CURRENT.md` (what task is active)
+3. Append to `.claude/session-state/squirrels.md`:
+   ```
+   - YYYY-MM-DD: [idea] (context: [current task summary])
+   ```
+4. Confirm: "Parked: [idea]"
+5. Return to current work — do NOT expand on the idea or start working on it
+
+### `promote [N]` — Promote an idea
+
+1. Read squirrels.md, number the ideas (1-based, top to bottom)
+2. Display idea #N and ask: "Promote this to a plan, a task, or a session-state item?"
+3. Based on response:
+   - **Plan**: Create a plan stub in `.claude/plans/`
+   - **Task**: Add to CURRENT.md as an open item
+   - **Session-state**: Add to CURRENT.md as context
+4. Remove the idea from squirrels.md
+5. Confirm: "Promoted squirrel #N to [destination]"
+
+### `clean` — Clean stale ideas
+
+1. Read squirrels.md, display ALL ideas with numbers
+2. Ask user which to remove (by number, or "all aging" for ideas > 7 days old)
+3. Remove selected ideas
+4. Confirm: "Cleaned N squirrels. M remaining."
+
+---
+
+## Integration Points
+
+- `/massu-bearings` reads squirrels.md and surfaces the count + list
+- `/massu-recap` surfaces any squirrels added during the session
+- Squirrels are NOT automatically promoted — they require explicit user action
+- Squirrels are NOT persisted to memory/ — they are ephemeral by design
+
+---
+
+## Edge Cases
+
+- If `squirrels.md` doesn't exist: create it with the standard header format
+- If `CURRENT.md` doesn't exist when adding context: use "no active task" as context
+- If promote target #N doesn't exist: show the list and ask again
+
+---
+
+## START NOW
+
+1. Parse `{{ARGUMENTS}}` to determine action (show/add/review/promote/clean)
+2. Read `.claude/session-state/squirrels.md`
+3. Execute the appropriate action
+4. Return to current work without expanding on the idea