@polymorphism-tech/morph-spec 4.21.0 → 5.0.1

package/framework/agents/integrations/neon-auth.md

@@ -1,151 +0,0 @@
----
-name: neon-auth
-description: Neon Auth (Better Auth) specialist for authentication flows, session management, Next.js App Router integration, .NET JWT validation, and RLS policy integration. Use when integrating Neon Auth, implementing social login flows, managing user sessions, or protecting routes with Neon Auth middleware.
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep
-stacks:
-  - neon
-color: teal
-effort: medium
----
-
-# Neon Auth (Better Auth)
-
-Authentication with Neon Auth for Next.js and .NET. SDK: `@neondatabase/auth` (Next.js) / JWT Bearer validation (.NET).
-
-> **Ref:** `framework/standards/backend/integrations/neon-auth/neon-auth.md`
-
-## Setup (Next.js)
-
-```typescript
-// lib/auth/client.ts
-'use client';
-import { createAuthClient } from '@neondatabase/auth/next';
-export const authClient = createAuthClient();
-
-// lib/auth/server.ts
-import { createNeonAuth } from '@neondatabase/auth/next/server';
-export const auth = createNeonAuth({
-  baseUrl: process.env.NEON_AUTH_BASE_URL!,
-  cookies: { secret: process.env.NEON_AUTH_COOKIE_SECRET! },
-});
-
-// app/api/auth/[...path]/route.ts
-import { auth } from '@/lib/auth/server';
-export const { GET, POST } = auth.handler();
-```
-
-## Setup (.NET)
-
-```csharp
-// Program.cs
-builder.Services.AddAuthentication("NeonAuth")
-    .AddJwtBearer("NeonAuth", options =>
-    {
-        options.Authority = builder.Configuration["NeonAuth:BaseUrl"];
-        options.TokenValidationParameters = new()
-        {
-            ValidateIssuer = true,
-            ValidateAudience = false,
-            ValidateLifetime = true,
-            ValidateIssuerSigningKey = true,
-            NameClaimType = "sub"
-        };
-    });
-builder.Services.AddAuthorization();
-app.UseAuthentication();
-app.UseAuthorization();
-```
-
-## Protected Endpoints
-
-```csharp
-// Minimal API
-app.MapGet("/api/profile", (ClaimsPrincipal user) =>
-{
-    var userId = user.FindFirstValue("sub");
-    if (userId is null) return Results.Unauthorized();
-    return Results.Ok(new { UserId = userId });
-}).RequireAuthorization();
-
-// Controller: same pattern with [Authorize] + User.FindFirstValue("sub")
-```
-
-## Next.js Integration
-
-```tsx
-// middleware.ts
-import { auth } from '@/lib/auth/server';
-export default auth.middleware({ loginUrl: '/auth/sign-in' });
-export const config = { matcher: ['/((?!.*\\..*|_next|auth).*)', '/'] };
-
-// Protected page (server)
-import { auth } from '@/lib/auth/server';
-export const dynamic = 'force-dynamic';
-export default async function DashboardPage() {
-  const { data: session } = await auth.getSession();
-  if (!session?.user) redirect('/auth/sign-in');
-  return <Dashboard user={session.user} />;
-}
-
-// Client component
-'use client';
-import { useSession } from '@/lib/auth/client';
-const { data } = useSession();
-const user = data?.user;
-```
-
-## Auth Pages
-
-```tsx
-// Sign in / Sign up — single component
-import { AuthView } from '@neondatabase/auth/react';
-export default function SignInPage() {
-  return <AuthView pathname="sign-in" />;
-}
-```
-
-## OAuth
-
-```typescript
-await authClient.signIn.social({
-  provider: 'google',
-  callbackURL: '/auth/callback',
-});
-```
-
-## RLS Integration
-
-Neon Auth JWTs are validated by the Data API. Use `auth.user_id()` in RLS policies:
-
-```sql
-CREATE POLICY "Users own rows"
-  ON public.documents FOR ALL TO authenticated
-  USING (user_id = auth.user_id());
-```
-
-## Database Schema
-
-Auth data lives in `neon_auth` schema (managed automatically):
-- `neon_auth.user` — profiles
-- `neon_auth.session` — sessions
-- `neon_auth.account` — credentials
-
-Query directly — no webhook sync needed:
-```sql
-SELECT id, email, name FROM neon_auth.user WHERE id = auth.user_id();
-```
-
-## Checklist
-
-- [ ] `NEON_AUTH_BASE_URL` in environment variables
-- [ ] `NEON_AUTH_COOKIE_SECRET` (32+ chars) in environment variables
-- [ ] Auth API route at `app/api/auth/[...path]/route.ts`
-- [ ] `NeonAuthUIProvider` wrapping app in root layout
-- [ ] Middleware protecting private routes
-- [ ] `.NET` JWT Bearer configured with Neon Auth authority
-- [ ] RLS policies using `auth.user_id()`
-- [ ] `force-dynamic` on pages using `auth.getSession()`
-
----
-
-*MORPH-SPEC by Polymorphism Tech*

package/framework/agents/integrations/resend-email.md

@@ -1,127 +0,0 @@
----
-name: resend-email
-description: Resend Email specialist for transactional email, HTML/React email templates, Resend API integration, and notification systems in .NET and Next.js. Use when implementing email notifications, integrating Resend API, creating transactional email templates, or configuring email delivery in MORPH-SPEC projects.
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep
-stacks:
-  - resend
-color: teal
-effort: medium
----
-
-# Resend Email
-
-Transactional email via Resend for .NET. REST API, no official SDK. Simple, developer-friendly.
-
-## Setup
-
-```csharp
-// appsettings.json
-{ "Resend": { "BaseUrl": "https://api.resend.com", "ApiKey": "${RESEND_API_KEY}", "FromEmail": "noreply@yourdomain.com" } }
-
-// Program.cs
-builder.Services.Configure<ResendOptions>(builder.Configuration.GetSection("Resend"));
-builder.Services.AddHttpClient<IResendClient, ResendClient>((sp, client) =>
-{
-    var options = sp.GetRequiredService<IOptions<ResendOptions>>().Value;
-    client.BaseAddress = new Uri(options.BaseUrl);
-    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", options.ApiKey);
-});
-```
-
-## Client Interface
-
-```csharp
-public interface IResendClient
-{
-    Task<EmailResponse> SendAsync(SendEmailRequest request, CancellationToken ct = default);
-    Task<EmailResponse> SendBatchAsync(IEnumerable<SendEmailRequest> requests, CancellationToken ct = default);
-    Task<EmailDetails> GetEmailAsync(string emailId, CancellationToken ct = default);
-}
-```
-
-Implementation: `HttpClient.PostAsJsonAsync("/emails")` + `ReadFromJsonAsync<EmailResponse>`. Log errors, throw `ResendException` on failure.
-
-## DTOs
-
-```csharp
-public record SendEmailRequest
-{
-    [JsonPropertyName("from")] public required string From { get; init; }
-    [JsonPropertyName("to")] public required string[] To { get; init; }
-    [JsonPropertyName("subject")] public required string Subject { get; init; }
-    [JsonPropertyName("html")] public string? Html { get; init; }
-    [JsonPropertyName("text")] public string? Text { get; init; }
-    [JsonPropertyName("reply_to")] public string? ReplyTo { get; init; }
-    [JsonPropertyName("tags")] public Tag[]? Tags { get; init; }
-}
-
-public record EmailResponse
-{
-    [JsonPropertyName("id")] public string Id { get; init; } = "";
-}
-
-public record Tag
-{
-    [JsonPropertyName("name")] public required string Name { get; init; }
-    [JsonPropertyName("value")] public required string Value { get; init; }
-}
-```
-
-## Webhooks
-
-```csharp
-[ApiController, Route("api/webhooks/resend")]
-public class ResendWebhookController(IEmailTrackingService tracking, ILogger<ResendWebhookController> logger) : ControllerBase
-{
-    [HttpPost]
-    public async Task<IActionResult> Handle([FromBody] ResendWebhookPayload payload)
-    {
-        logger.LogInformation("Resend webhook: {Type} for {EmailId}", payload.Type, payload.Data?.EmailId);
-        switch (payload.Type)
-        {
-            case "email.delivered": await tracking.MarkDeliveredAsync(payload.Data!.EmailId); break;
-            case "email.bounced": await tracking.MarkBouncedAsync(payload.Data!.EmailId); break;
-            case "email.complained": await tracking.MarkComplainedAsync(payload.Data!.EmailId); break;
-        }
-        return Ok();
-    }
-}
-```
-
-## Abstraction Pattern
-
-```csharp
-// Use IEmailService abstraction over IResendClient for testability
-public interface IEmailService
-{
-    Task<string> SendTransactionalAsync(string to, string subject, string htmlBody, CancellationToken ct = default);
-}
-
-// ResendEmailService implements IEmailService using IResendClient
-// FakeEmailClient implements IEmailService for simulation mode
-```
-
-## Gotchas
-
-| Issue | Fix |
-|-------|-----|
-| Rate limit: 100 req/sec (free), 1000 (pro) | Queue emails via Hangfire for bulk sends |
-| Domain verification required for production | Verify in Resend dashboard, add DNS records |
-| `from` must match verified domain | Use `noreply@yourdomain.com` |
-| HTML email rendering varies | Test with Litmus/Email on Acid, use MJML |
-| Webhook signature validation | Verify `svix-signature` header in production |
-
-## Checklist
-
-- [ ] API Key in Key Vault (not hardcoded)
-- [ ] HttpClient with `Authorization: Bearer` header
-- [ ] Domain verified in Resend dashboard
-- [ ] `IEmailService` abstraction for testability
-- [ ] Webhook endpoint + signature validation
-- [ ] Rate limiting handled (queue for bulk)
-- [ ] Tags used for tracking/analytics
-- [ ] Simulation mode (`FakeEmailClient`) for dev
-
----
-
-*MORPH-SPEC by Polymorphism Tech*

package/framework/hooks/claude-code/post-tool-use/agent-complete.js

@@ -1,122 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUse Hook: Agent Completion Tracker
- *
- * Event: PostToolUse | Matcher: Agent
- *
- * Detects when morph-spec subagents complete (dispatched via the Agent tool)
- * and injects status notifications:
- *   - Partial: shows which agents are still pending
- *   - Complete: instructs to run validate-feature
- *
- * Only tracks tier 1-3 agents (not validators: morph-validator-*).
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { readStdin } from '../../shared/stdin-reader.js';
-import { stateExists, getActiveFeature, getFeature, getFeaturePhase } from '../../shared/state-reader.js';
-import { pass, injectContext } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-import { subagentTypeToAgentId } from '../../shared/dispatch-helpers.js';
-
-try {
-  if (!stateExists()) pass();
-
-  const payload = await readStdin();
-  if (!payload) pass();
-
-  const subagentType = payload?.tool_input?.subagent_type || '';
-  if (!subagentType) pass();
-
-  // Only track morph-* agents (not external subagents)
-  if (!subagentType.startsWith('morph-')) pass();
-
-  // Skip validators (tier 4) — they have their own tracking
-  if (subagentType.startsWith('morph-validator-')) pass();
-
-  const result = buildAgentCompleteContext(subagentType);
-  if (result) {
-    logHookActivity('agent-complete', 'PostToolUse', result.type);
-    injectContext(result.text);
-  }
-
-  pass();
-} catch {
-  // Fail-open
-  process.exit(0);
-}
-
-/**
- * Build the agent completion notification context.
- *
- * @param {string} subagentType - e.g. 'morph-nextjs-expert'
- * @returns {{ text: string, type: string }|null}
- */
-function buildAgentCompleteContext(subagentType) {
-  // Get active feature
-  const active = getActiveFeature();
-  if (!active) return null;
-
-  const { name: featureName, feature } = active;
-
-  // Only track during implement phase
-  const phase = getFeaturePhase(featureName);
-  if (phase !== 'implement') return null;
-
-  // Get dispatch log
-  const dispatchLog = feature.dispatchLog;
-  if (!Array.isArray(dispatchLog) || dispatchLog.length === 0) return null;
-
-  // Get the most recent dispatch entry
-  const latestDispatch = dispatchLog[dispatchLog.length - 1];
-  const agents = latestDispatch?.agents;
-  if (!Array.isArray(agents) || agents.length === 0) return null;
-
-  // Find the completing agent in the dispatch
-  const agentId = subagentTypeToAgentId(subagentType);
-  let matchedAgent = agents.find(a => a.subagentType === subagentType);
-  if (!matchedAgent && agentId) {
-    matchedAgent = agents.find(a => a.id === agentId);
-  }
-
-  if (!matchedAgent) return null;
-
-  // Mark this agent as completed (in-memory for evaluation only)
-  // Check which agents are still pending (no completedAt)
-  const pendingAgents = agents.filter(a => {
-    if (a === matchedAgent) return false; // The one just completed
-    return !a.completedAt;
-  });
-
-  const totalAgents = agents.length;
-  const completedCount = totalAgents - pendingAgents.length;
-
-  if (pendingAgents.length === 0) {
-    // All agents complete
-    return {
-      type: 'all_complete',
-      text: [
-        '✅ ALL MORPH-SPEC AGENTS COMPLETE',
-        '════════════════════════════════════════',
-        `All ${totalAgents} dispatched agents have completed their tasks.`,
-        '',
-        'NEXT STEP:',
-        `  morph-spec validate-feature ${featureName} --phase implement`,
-      ].join('\n'),
-    };
-  }
-
-  // Partial completion
-  const remainingList = pendingAgents
-    .map(a => a.title || a.id || 'unknown')
-    .join(', ');
-
-  const agentTitle = matchedAgent.title || matchedAgent.id || subagentType;
-
-  return {
-    type: 'partial_complete',
-    text: `✅ Agent '${agentTitle}' completed (${completedCount}/${totalAgents}). Remaining: ${remainingList}`,
-  };
-}