@mr.dj2u/knowledge 0.1.0

package/dist/content/checklists/ship-test-loop.md

@@ -0,0 +1,16 @@
+# Ship-Test Loop Checklist
+
+Use this checklist when running the PR loop into `test`.
+
+1. Doctor CI pass: `mds doctor --ci`.
+2. Stage intentional files only.
+3. Create meaningful commit message.
+4. Push branch.
+5. Open/update PR to `test`.
+6. Wait ~2 minutes before polling checks/comments.
+7. Collect failed checks + review comments.
+8. Fix issues locally.
+9. Rerun Doctor CI.
+10. Push and poll again.
+11. Repeat up to 5 cycles.
+12. Merge only when checks are green and blockers are cleared.

package/dist/content/checklists/unified-agent-bundle-validation.md

@@ -0,0 +1,8 @@
+# Unified Agent Bundle Validation Checklist
+
+Phase 9 validation artifact intent:
+
+1. Run Doctor (`--ci`) through the agent.
+2. Fetch one guide via MCP resource (`animation-performance`).
+3. Execute one CLI workflow (`mds continue` or `/ship-test-loop`).
+4. Confirm tools/resources are visible in the target client.

package/dist/content/examples/ship-test-loop.md

@@ -0,0 +1,13 @@
+# Ship-Test Loop Example
+
+Example iteration log for `/ship-test-loop`:
+
+- Iteration 1:
+  - Failed: `lint` and one requested review change.
+  - Fixes: remove dead import, update API guard clause.
+  - Result: `lint` green, one test still failing.
+- Iteration 2:
+  - Failed: `test` in `packages/cli`.
+  - Fixes: update stale skill ID expectation.
+  - Result: all checks green.
+- Merge: PR merged into `test`.

package/dist/content/examples/unified-agent-bundle-bootstrap.md

@@ -0,0 +1,8 @@
+# Unified Agent Bundle Bootstrap Example
+
+Phase 9 bootstrap artifact intent:
+
+1. Install MCP server config.
+2. Install generated skills/prompts package.
+3. Verify the agent can call Doctor + knowledge tools.
+4. Verify the agent can run one CLI workflow.

package/dist/content/guides/animation-performance.md

@@ -0,0 +1,30 @@
+# Animation Performance Guide
+
+Source: Expo blog, "The real cost of React Native animations: benchmarking
+every approach" by App & Flow:
+https://expo.dev/blog/the-real-cost-of-react-native-animations-benchmarking-every-approach
+
+## Practical Guidance
+
+- Measure animation cost in release builds before changing libraries. Debug
+  builds can exaggerate overhead, especially for Reanimated.
+- Library choice matters most for long-running animations, large animated lists,
+  low-end Android devices, and screens with many simultaneously animated views.
+- Library choice matters less for short one-shot transitions where animation
+  work ends quickly and the component count is low.
+- Prefer native/platform-driven animation paths for large repeated animations
+  when the interaction does not require gesture coupling or complex shared
+  values.
+- Keep Reanimated for gesture-driven interactions, layout-sensitive motion, and
+  complex UI-thread coordination.
+- Animated view count is a budget. A single animated card is different from 100
+  animated rows.
+
+## Doctor And Onboarding Rules
+
+- Warn when route or list files animate many repeated items without an explicit
+  performance note.
+- Warn when benchmark claims are based only on debug builds.
+- Ask during onboarding whether the app has long-running, list-heavy, or
+  gesture-heavy animation requirements.
+

package/dist/content/guides/post-create-onboarding.md

@@ -0,0 +1,113 @@
+# Post-Create Expo Onboarding
+
+MDS onboarding runs after `rn-new`, `create-expo-app`, `create-expo-stack`, or
+another generator has created an Expo project. `create-expo-super-stack` wraps
+that same idea by running `create-expo-stack` first and then applying the MDS
+onboarding pass.
+
+## Flow
+
+1. Detect package manager, Expo SDK, Expo Router, app directory, aliases, and
+   styling stack.
+2. Explain project memory first, then ask what the app is for, who it serves,
+   primary flows, data needs, and release/deployment intent.
+3. Use friendly Clack prompts with visible defaults, helpful explanations, and
+   no blank required answers.
+4. Derive defaults from selected answers instead of asking for comma-separated
+   internal keywords.
+5. Offer rich boilerplate by default: project memory docs, exposition pages,
+   Uniwind repair for existing apps, Software Mansion core examples, Supabase or
+   local data guidance, MCP/Codex/Claude instructions, and CI/release safeguards.
+6. Scaffold only selected pieces.
+7. Add generated cleanup scripts such as `clear-expo-start` and `free-port` (with `kill-port` compatibility alias).
+8. Install added dependencies, run `expo install --fix`, install known missing
+   Expo peers such as `expo-font` for `@expo/vector-icons`, then run Doctor.
+
+## Agentic Onboarding (MCP)
+
+The terminal `mds onboard` command writes the project memory files. The
+agentic version is a conversation with Claude Code, Codex, or Cursor that
+fills those files in collaboratively.
+
+Install **once, globally** (user scope, default) so every workspace gets
+the prompts:
+
+```bash
+mds mcp install --client claude   # merges into ~/.claude.json
+mds mcp install --client codex    # merges into ~/.codex/config.toml
+mds mcp install --client cursor   # merges into ~/.cursor/mcp.json
+mds mcp install --dry-run         # preview merge before writing
+```
+
+Restart the host (or run `claude mcp reload`) and the MDS prompts are
+available from any workspace.
+
+Two prompts ship with the server:
+
+- `create_expo_super_stack` — invoke from a **parent folder** (e.g.
+  `F:\ReactNativeApps`) when the app folder does not exist yet. The
+  agent confirms platforms, styling, data start, etc., then runs
+  `create-expo-super-stack`, verifies the generated app folder, and
+  offers to resolve TodoForContext markers.
+- `onboard_new_expo_app` — invoke from **inside an existing Expo app
+  folder** (a freshly generated one or a year-old project). Runs the
+  intake → normalize → plan → scaffold flow.
+
+After generation, the user-dev should open the generated app folder
+directly in a new agent session and run `mds continue`. That fresh
+app-root session reduces token usage and saves money because future
+searches, reads, and plans are scoped to the app instead of the parent
+folder and old generator conversation.
+
+Both prompts enforce or surface a **TodoForContext blocker** before
+implementation work: they scan every `project/` file for the literal
+marker `# TodoForContext(optional):` and ask the user to fill it in or
+delete the marker line.
+
+`mds doctor` mirrors this rule with a `todo-for-context markers`
+error so the same blocker stops CI and editor surfaces until the user
+fills the section or deletes the marker line.
+
+### What's new in the agentic prompts
+
+- **PHASE 0 file intake.** The agent offers to digest an existing
+  `project/info.md` and `project/style.md` if the user has them already.
+  Questions whose answers are unambiguous in the file are skipped; the
+  agent asks for clarification only when the file is silent or unclear.
+  A reference template URL is mentioned in the prompt; the agent can
+  also inline the template on request.
+- **Android TV alongside Apple TV.** The platform multi-select now
+  includes Android TV. Android TV builds from the same Android target
+  with leanback config in `app.json`; Apple TV is a separate tvOS build
+  target via `react-native-tvos`. Selecting either records the intent
+  in project memory.
+- **Embedded flag map.** Both prompts now include the exact
+  create-expo-stack and `--mds-*` flag map so the agent does not have
+  to grep `node_modules` or scan source to translate answers into a
+  command. This was the biggest source of slowness in early test runs.
+- **Credits while waiting.** When generation kicks off, the agent
+  prints a recognition note for the upstream teams and individuals
+  whose work fills the MDS knowledge base.
+- **Success message surfaced.** After a successful run, the agent
+  quotes the generator's `MDS onboarding complete` tail block back
+  verbatim so the Mr. DJ thank-you text appears in chat the same way
+  it does in a terminal CLI run.
+- **MDS Continue handoff.** The agent runs `mds continue` from the
+  generated app folder, then tells the user-dev to open that app folder
+  in a fresh agent session to lower token usage and cost.
+
+## Defaults
+
+- Prefer Uniwind and Tailwind v4 for new projects.
+- Keep route files thin and move business logic into features, services, hooks,
+  and utilities.
+- Always add `project/info.md`, `project/todo.md`, `project/style.md`, and
+  `project/guidelines.md` when project memory is selected.
+- Normalize existing `project/info.md` and `project/style.md` into canonical
+  sections while preserving unknown content under Imported Notes.
+- Add `project/intake-agent.md` when context is thin or imported notes need a
+  follow-up agent conversation.
+- Keep `project/style.md` visual-only; put technical and agent rules in
+  `project/guidelines.md`.
+- Treat monorepo-aware scaffolding as a future step after the single-app MVP is
+  stable.

package/dist/content/patterns/api/api-routes.md

@@ -0,0 +1,314 @@
+# API Routes with Catch-All Pattern
+
+## Description
+
+Expo Router API routes use the `+api.ts` pattern to create server-side endpoints directly alongside client routes. The `[...segments]+api.ts` syntax creates catch-all routes that capture all path segments, enabling flexible API endpoint structures with full control over HTTP methods, CORS, and request handling.
+
+## When to Use
+
+**Use API routes** for:
+- ✅ Backend endpoints served from same domain as frontend
+- ✅ Proxy servers that forward requests upstream
+- ✅ Server-side validation and data transformation
+- ✅ Protected endpoints with authentication
+- ✅ Catch-all routes for dynamic path handling
+
+## Code Example
+
+### Basic API Route (Single Endpoint)
+
+```typescript
+// File: app/api/quantum-backend/[...segments]+api.ts
+import { ExpoRequest, ExpoResponse } from 'expo-server-rendering';
+
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+
+const ALLOWED_ORIGINS = [
+  'http://localhost:3000',
+  'http://localhost:8081',
+  'http://127.0.0.1:3000',
+  'http://127.0.0.1:8081',
+];
+
+function normalizeOrigin(request: ExpoRequest): string | null {
+  const origin = request.headers.get('origin');
+  if (!origin) return null;
+  
+  return ALLOWED_ORIGINS.includes(origin) ? origin : null;
+}
+
+export async function GET(request: ExpoRequest) {
+  const allowedOrigin = normalizeOrigin(request);
+  
+  if (request.method === 'OPTIONS') {
+    return new ExpoResponse(null, {
+      status: 204,
+      headers: allowedOrigin
+        ? { 'Access-Control-Allow-Origin': allowedOrigin }
+        : {},
+    });
+  }
+
+  // Handle GET request
+  return new ExpoResponse(JSON.stringify({ message: 'GET OK' }), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(allowedOrigin && {
+        'Access-Control-Allow-Origin': allowedOrigin,
+      }),
+    },
+  });
+}
+
+export async function POST(request: ExpoRequest) {
+  const allowedOrigin = normalizeOrigin(request);
+  const body = await request.json();
+  
+  // Process request
+  const result = {
+    success: true,
+    data: body,
+  };
+
+  return new ExpoResponse(JSON.stringify(result), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(allowedOrigin && {
+        'Access-Control-Allow-Origin': allowedOrigin,
+      }),
+    },
+  });
+}
+```
+
+**From:** DJsPortfolio/src/app/api/quantum-backend/[...segments]+api.ts
+
+### Catch-All Route with Path Normalization
+
+```typescript
+// File: app/public-facing/api/quantum/v1/[...segments]+api.ts
+import { ExpoRequest, ExpoResponse } from 'expo-server-rendering';
+
+const DISALLOWED_PREFIXES = ['/v1/keys', '/v1/ibm/profiles'];
+const DEFAULT_UPSTREAM_BASE_URL = 'http://127.0.0.1:8000/v1';
+
+type ProxyMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+function normalizeUpstreamBaseUrl(): string {
+  const raw = process.env.EXPO_PUBLIC_QUANTUM_API_BASE_URL?.trim();
+  const base = raw || DEFAULT_UPSTREAM_BASE_URL;
+  
+  // Remove trailing slash
+  const trimmed = base.replace(/\/+$/, '');
+  
+  // Ensure /v1 suffix
+  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
+}
+
+function normalizeOperationPath(pathname: string): string {
+  // Remove leading/trailing slashes, lowercase
+  return `/${pathname.toLowerCase().trim().replace(/^\/+|\/+$/g, '')}`;
+}
+
+export async function POST(request: ExpoRequest) {
+  try {
+    // Parse segments from URL
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    
+    // Extract segments after route prefix
+    const segments = pathname
+      .replace('/public-facing/api/quantum/v1', '')
+      .split('/')
+      .filter(Boolean);
+    
+    const operationPath = '/' + segments.join('/');
+    
+    // Validate disallowed paths
+    for (const prefix of DISALLOWED_PREFIXES) {
+      if (operationPath.startsWith(prefix)) {
+        return new ExpoResponse(
+          JSON.stringify({ error: 'Path not allowed' }),
+          { status: 403, headers: { 'Content-Type': 'application/json' } }
+        );
+      }
+    }
+    
+    // Forward to upstream
+    const upstreamUrl = normalizeUpstreamBaseUrl() + operationPath;
+    const upstreamRequest = new Request(upstreamUrl, {
+      method: 'POST',
+      headers: request.headers,
+      body: await request.text(),
+    });
+    
+    const response = await fetch(upstreamRequest);
+    return new ExpoResponse(await response.text(), {
+      status: response.status,
+      headers: Object.fromEntries(response.headers),
+    });
+  } catch (error) {
+    return new ExpoResponse(
+      JSON.stringify({ error: 'Internal Server Error' }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    );
+  }
+}
+```
+
+**From:** DJsPortfolio/src/app/public-facing/api/quantum/v1/[...segments]+api.ts (lines 1-50)
+
+## Configuration
+
+### Enable API Routes in app.json
+
+```json
+{
+  "expo": {
+    "plugins": [
+      [
+        "expo-router",
+        {
+          "apiRoutes": true,
+          "origin": false
+        }
+      ]
+    ]
+  }
+}
+```
+
+### Environment Variables for API Base URLs
+
+```bash
+# .env or .env.production
+EXPO_PUBLIC_QUANTUM_API_BASE_URL=http://127.0.0.1:8000/v1
+QUANTUM_UPSTREAM_API_SECRET=your-secret-key
+```
+
+### TypeScript Setup
+
+```typescript
+import { ExpoRequest, ExpoResponse } from 'expo-server-rendering';
+
+export type { ExpoRequest, ExpoResponse };
+
+// Type for allowed HTTP methods
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+```
+
+## Best Practices
+
+### ✅ DO
+
+1. **Always validate CORS origin** before responding
+   ```typescript
+   const ALLOWED_ORIGINS = ['http://localhost:3000', 'https://app.example.com'];
+   
+   function validateOrigin(origin: string | null): boolean {
+     return !!origin && ALLOWED_ORIGINS.includes(origin);
+   }
+   ```
+
+2. **Normalize paths and trim trailing slashes**
+   ```typescript
+   function normalizePath(path: string): string {
+     return path.replace(/\/+$/, '').toLowerCase();
+   }
+   ```
+
+3. **Use explicit status codes**
+   ```typescript
+   // ✅ GOOD
+   return new ExpoResponse(JSON.stringify(error), {
+     status: 400,
+     headers: { 'Content-Type': 'application/json' },
+   });
+   ```
+
+4. **Handle disallowed paths explicitly**
+   ```typescript
+   const DISALLOWED_PREFIXES = ['/keys', '/credentials'];
+   
+   for (const prefix of DISALLOWED_PREFIXES) {
+     if (operationPath.startsWith(prefix)) {
+       return new ExpoResponse(
+         JSON.stringify({ error: 'Forbidden' }),
+         { status: 403 }
+       );
+     }
+   }
+   ```
+
+5. **Support OPTIONS preflight requests**
+   ```typescript
+   if (request.method === 'OPTIONS') {
+     return new ExpoResponse(null, {
+       status: 204,
+       headers: corsHeaders,
+     });
+   }
+   ```
+
+### ❌ DON'T
+
+1. **Don't skip CORS validation**
+   ```typescript
+   // ❌ BAD - allows any origin
+   headers: { 'Access-Control-Allow-Origin': '*' }
+   
+   // ✅ GOOD - restrict to known origins
+   if (ALLOWED_ORIGINS.includes(origin)) {
+     headers: { 'Access-Control-Allow-Origin': origin }
+   }
+   ```
+
+2. **Don't expose sensitive environment variables**
+   ```typescript
+   // ❌ BAD
+   headers: process.env.API_SECRET
+   
+   // ✅ GOOD - only use server-side secrets
+   const secret = process.env.API_SECRET; // Used in headers, not exposed
+   ```
+
+3. **Don't pass unchecked path segments to upstream**
+   ```typescript
+   // ❌ BAD - could be exploited
+   const upstreamUrl = baseUrl + segments;
+   
+   // ✅ GOOD - validate and normalize
+   const validatedPath = normalizePath(segments);
+   const upstreamUrl = baseUrl + validatedPath;
+   ```
+
+4. **Don't forget to handle errors**
+   ```typescript
+   // ❌ BAD - uncaught errors crash request
+   const data = await request.json();
+   
+   // ✅ GOOD - catch and return error response
+   try {
+     const data = await request.json();
+   } catch (error) {
+     return new ExpoResponse(
+       JSON.stringify({ error: 'Invalid JSON' }),
+       { status: 400 }
+     );
+   }
+   ```
+
+## Related Patterns
+
+- [File-Based Routing](./file-based-routing.md) — Route file structure
+- [Error Handling](../api/error-handling.md) — Custom error classes
+- [CORS Configuration](../api/cors-configuration.md) — Origin validation
+- [Health Endpoints](../api/health-endpoints.md) — Health check patterns
+
+---
+
+*Pattern extracted from production repositories: DJsPortfolio, PokePages*
+*Files: DJsPortfolio/src\app\api\quantum-backend\[...segments]+api.ts*
+*Lines 1-40 of catch-all route pattern with path normalization*