@medicine-wheel/app 0.4.12 → 0.5.0

package/app/accountability/layout.tsx

@@ -0,0 +1,7 @@
+import type { Metadata } from "next";
+
+export const metadata: Metadata = { title: "Accountability" };
+
+export default function AccountabilityLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}

package/app/accountability/page.tsx

@@ -40,7 +40,7 @@ export default function AccountabilityPage() {
 
   return (
     <div className="p-6 max-w-5xl mx-auto">
-      <h1 className="text-2xl font-bold mb-2">Accountability & Frameworks</h1>
+      <h1 className="mw-h1 mb-2">Accountability & frameworks</h1>
       <p className="text-sm text-muted-foreground mb-6">Relational accountability metrics and Indigenous research frameworks</p>
 
       {loading && <div className="text-center py-16 text-muted-foreground">Loading accountability metrics…</div>}
@@ -49,26 +49,26 @@ export default function AccountabilityPage() {
       <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-8">
         <div className="p-4 rounded-lg border bg-card text-center">
           <p className="text-3xl font-bold">{nodes.length}</p>
-          <p className="text-sm text-muted-foreground">Relations Mapped</p>
+          <p className="text-sm text-muted-foreground">Relations mapped</p>
           <p className="text-xs text-muted-foreground">{nodes.length} nodes · {edges.length} edges</p>
         </div>
         <div className="p-4 rounded-lg border bg-card text-center">
           <p className="text-3xl font-bold">{ceremonies.length}</p>
-          <p className="text-sm text-muted-foreground">Ceremonies Logged</p>
+          <p className="text-sm text-muted-foreground">Ceremonies logged</p>
         </div>
         <div className="p-4 rounded-lg border bg-card text-center">
           <p className="text-3xl font-bold">{beats.length}</p>
-          <p className="text-sm text-muted-foreground">Narrative Beats</p>
+          <p className="text-sm text-muted-foreground">Narrative beats</p>
         </div>
         <div className="p-4 rounded-lg border bg-card text-center">
-          <p className="text-3xl font-bold text-green-500">{ceremoniedCount > 0 ? "✓" : "○"}</p>
-          <p className="text-sm text-muted-foreground">Relations Ceremonied</p>
+          <p className="text-3xl font-bold" style={{ color: "var(--mw-wilson-high)" }}>{ceremoniedCount > 0 ? "✓" : "○"}</p>
+          <p className="text-sm text-muted-foreground">Relations ceremonied</p>
           <p className="text-xs text-muted-foreground">{ceremoniedCount}/{edges.length} edges ceremonied</p>
         </div>
       </div>
 
       {/* Frameworks */}
-      <h2 className="text-lg font-semibold mb-4">Indigenous Research Frameworks</h2>
+      <h2 className="mw-h2 mb-4">Indigenous research frameworks</h2>
       <div className="space-y-3">
         {resources.map((res) => (
           <div key={res.id} className="border rounded-lg bg-card overflow-hidden cursor-pointer hover:border-ring/50"

package/app/api/edges/route.ts

@@ -1,5 +1,87 @@
 import { NextResponse } from "next/server";
-import { createProvider, detectProvider } from "@medicine-wheel/storage-provider";
+import { z } from "zod";
+import {
+  createProvider,
+  detectProvider,
+  EdgeNotFoundError,
+} from "@medicine-wheel/storage-provider";
+
+const EdgeCreateSchema = z.object({
+  from_id: z.string({ required_error: "from_id is required" }).trim().min(1),
+  to_id: z.string({ required_error: "to_id is required" }).trim().min(1),
+  relationship_type: z
+    .string({ required_error: "relationship_type is required" })
+    .trim()
+    .min(1, "cannot be empty"),
+  strength: z.number().min(0).max(1).optional(),
+  ceremony_honored: z.boolean().optional(),
+  obligations: z.array(z.string()).optional(),
+});
+
+const EdgePatchSchema = z
+  .object({
+    relationship_type: z.string().trim().min(1, "cannot be empty").optional(),
+    strength: z.number().min(0).max(1).optional(),
+    ceremony_honored: z.boolean().optional(),
+    obligations: z.array(z.string()).optional(),
+  })
+  .strict()
+  .refine((patch) => Object.keys(patch).length > 0, {
+    message:
+      "Provide at least one field to change: relationship_type, strength, ceremony_honored, or obligations.",
+  });
+
+/**
+ * Relations are identified by their pair of nodes (from → to).
+ * Accepts ?from=&to=, ?id=<from>:<to>, or from_id/to_id in the body.
+ */
+function resolvePair(
+  request: Request,
+  body: Record<string, unknown> | null,
+): { from: string; to: string } | null {
+  const { searchParams } = new URL(request.url);
+  let from = searchParams.get("from");
+  let to = searchParams.get("to");
+
+  const composite = searchParams.get("id");
+  if ((!from || !to) && composite && composite.includes(":")) {
+    const separator = composite.indexOf(":");
+    from = composite.slice(0, separator);
+    to = composite.slice(separator + 1);
+  }
+
+  if ((!from || !to) && body) {
+    if (!from && typeof body.from_id === "string") from = body.from_id;
+    if (!to && typeof body.to_id === "string") to = body.to_id;
+  }
+
+  return from && to ? { from, to } : null;
+}
+
+function pairRequired() {
+  return NextResponse.json(
+    {
+      error: "Relation not identified — nothing was changed.",
+      hint: "Identify the relation with ?from=<node-id>&to=<node-id> (or ?id=<from>:<to>).",
+    },
+    { status: 400 },
+  );
+}
+
+function relationNotFound(from: string, to: string) {
+  return NextResponse.json(
+    {
+      error: `No relation exists from ${from} to ${to}.`,
+      hint: "Relations are directional — check the from/to order, or refresh the relations list.",
+    },
+    { status: 404 },
+  );
+}
+
+function unexpected(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return NextResponse.json({ error: message }, { status: 500 });
+}
 
 export async function GET() {
   try {
@@ -7,30 +89,131 @@ export async function GET() {
     const edges = await store.getAllEdges();
     return NextResponse.json(edges);
   } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    return NextResponse.json({ error: message }, { status: 500 });
+    return unexpected(error);
   }
 }
 
 export async function POST(request: Request) {
   try {
+    const body = await request.json().catch(() => null);
+    const parsed = EdgeCreateSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        {
+          error: "Invalid relation — nothing was created.",
+          issues: parsed.error.issues.map(
+            (issue) => `${issue.path.join(".") || "body"}: ${issue.message}`,
+          ),
+        },
+        { status: 400 },
+      );
+    }
+
+    if (parsed.data.from_id === parsed.data.to_id) {
+      return NextResponse.json(
+        {
+          error: "A relation needs two distinct nodes.",
+          hint: "Choose a different node for one end of the relation.",
+        },
+        { status: 400 },
+      );
+    }
+
     const store = await createProvider();
-    const body = await request.json();
-    
+
+    // Relational accountability: both ends must exist before a thread is woven.
+    const [fromNode, toNode] = await Promise.all([
+      store.getNode(parsed.data.from_id),
+      store.getNode(parsed.data.to_id),
+    ]);
+    const missing = [
+      ...(fromNode ? [] : [parsed.data.from_id]),
+      ...(toNode ? [] : [parsed.data.to_id]),
+    ];
+    if (missing.length > 0) {
+      return NextResponse.json(
+        {
+          error: `Cannot weave a relation to a node that does not exist: ${missing.join(", ")}.`,
+          hint: "Create the node first on /nodes, then weave the relation.",
+        },
+        { status: 404 },
+      );
+    }
+
+    const replaced = Boolean(await store.getEdge(parsed.data.from_id, parsed.data.to_id));
+
     const edge = {
-      from_id: body.from_id,
-      to_id: body.to_id,
-      relationship_type: body.relationship_type,
-      strength: body.strength ?? 0.5,
-      ceremony_honored: body.ceremony_honored ?? false,
-      obligations: body.obligations ?? [],
+      from_id: parsed.data.from_id,
+      to_id: parsed.data.to_id,
+      relationship_type: parsed.data.relationship_type,
+      strength: parsed.data.strength ?? 0.5,
+      ceremony_honored: parsed.data.ceremony_honored ?? false,
+      obligations: parsed.data.obligations ?? [],
       created_at: new Date().toISOString(),
     };
-    
+
     await store.createEdge(edge);
-    return NextResponse.json({ success: true, edge, provider: detectProvider() }, { status: 201 });
+    return NextResponse.json(
+      { success: true, edge, replaced, provider: detectProvider() },
+      { status: 201 },
+    );
+  } catch (error: unknown) {
+    return unexpected(error);
+  }
+}
+
+export async function PATCH(request: Request) {
+  try {
+    const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+    const pair = resolvePair(request, body);
+    if (!pair) return pairRequired();
+
+    // from_id/to_id in the body only identify the relation — strip before validating the patch.
+    const patchBody = body ? { ...body } : {};
+    delete patchBody.from_id;
+    delete patchBody.to_id;
+
+    const parsed = EdgePatchSchema.safeParse(patchBody);
+    if (!parsed.success) {
+      return NextResponse.json(
+        {
+          error: "Invalid relation patch — nothing was changed.",
+          issues: parsed.error.issues.map(
+            (issue) => `${issue.path.join(".") || "body"}: ${issue.message}`,
+          ),
+        },
+        { status: 400 },
+      );
+    }
+
+    const store = await createProvider();
+    const edge = await store.updateEdge(pair.from, pair.to, parsed.data);
+    return NextResponse.json({ success: true, edge, provider: detectProvider() });
+  } catch (error: unknown) {
+    if (error instanceof EdgeNotFoundError) {
+      return relationNotFound(error.fromId, error.toId);
+    }
+    return unexpected(error);
+  }
+}
+
+export async function DELETE(request: Request) {
+  try {
+    const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+    const pair = resolvePair(request, body);
+    if (!pair) return pairRequired();
+
+    const store = await createProvider();
+    await store.deleteEdge(pair.from, pair.to);
+    return NextResponse.json({
+      success: true,
+      deleted: { from_id: pair.from, to_id: pair.to },
+      provider: detectProvider(),
+    });
   } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    return NextResponse.json({ error: message }, { status: 500 });
+    if (error instanceof EdgeNotFoundError) {
+      return relationNotFound(error.fromId, error.toId);
+    }
+    return unexpected(error);
   }
 }

package/app/api/nodes/[id]/route.ts

@@ -0,0 +1,101 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { DirectionNameSchema, NodeTypeSchema } from "@medicine-wheel/ontology-core";
+import {
+  createProvider,
+  detectProvider,
+  NodeNotFoundError,
+  NodeHasRelationsError,
+} from "@medicine-wheel/storage-provider";
+
+// `direction: null` releases the node from its direction.
+const NodePatchSchema = z
+  .object({
+    name: z.string().trim().min(1, "cannot be empty").optional(),
+    type: NodeTypeSchema.optional(),
+    description: z.string().optional(),
+    direction: DirectionNameSchema.nullable().optional(),
+    metadata: z.record(z.unknown()).optional(),
+  })
+  .strict()
+  .refine((patch) => Object.keys(patch).length > 0, {
+    message:
+      "Provide at least one field to change: name, type, description, direction, or metadata.",
+  });
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+function notFound(id: string) {
+  return NextResponse.json(
+    {
+      error: `Node not found: ${id}`,
+      hint: "It may already be released — refresh the nodes list.",
+    },
+    { status: 404 },
+  );
+}
+
+function unexpected(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return NextResponse.json({ error: message }, { status: 500 });
+}
+
+export async function GET(_request: Request, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const store = await createProvider();
+    const node = await store.getNode(id);
+    if (!node) return notFound(id);
+    return NextResponse.json({ node, provider: detectProvider() });
+  } catch (error: unknown) {
+    return unexpected(error);
+  }
+}
+
+export async function PATCH(request: Request, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const body = await request.json().catch(() => null);
+    const parsed = NodePatchSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        {
+          error: "Invalid node patch — nothing was changed.",
+          issues: parsed.error.issues.map(
+            (issue) => `${issue.path.join(".") || "body"}: ${issue.message}`,
+          ),
+        },
+        { status: 400 },
+      );
+    }
+
+    const store = await createProvider();
+    const node = await store.updateNode(id, parsed.data);
+    return NextResponse.json({ success: true, node, provider: detectProvider() });
+  } catch (error: unknown) {
+    if (error instanceof NodeNotFoundError) return notFound(error.nodeId);
+    return unexpected(error);
+  }
+}
+
+export async function DELETE(_request: Request, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const store = await createProvider();
+    await store.deleteNode(id);
+    return NextResponse.json({ success: true, deleted: id, provider: detectProvider() });
+  } catch (error: unknown) {
+    if (error instanceof NodeNotFoundError) return notFound(error.nodeId);
+    if (error instanceof NodeHasRelationsError) {
+      return NextResponse.json(
+        {
+          error: error.message,
+          relation_count: error.relationCount,
+          hint: "Release its relations on /relations, then delete the node.",
+        },
+        { status: 409 },
+      );
+    }
+    return unexpected(error);
+  }
+}

package/app/api/nodes/route.ts

@@ -1,6 +1,21 @@
 import { NextResponse } from "next/server";
+import { z } from "zod";
+import { DirectionNameSchema, NodeTypeSchema } from "@medicine-wheel/ontology-core";
 import { createProvider, detectProvider } from "@medicine-wheel/storage-provider";
 
+const NodeCreateSchema = z.object({
+  id: z.string().trim().min(1).optional(),
+  name: z.string({ required_error: "name is required" }).trim().min(1, "cannot be empty"),
+  type: NodeTypeSchema,
+  description: z.string().optional(),
+  // Forms send "" when no direction is chosen — treat that as "no direction".
+  direction: z.preprocess(
+    (value) => (value === "" || value === null ? undefined : value),
+    DirectionNameSchema.optional(),
+  ),
+  metadata: z.record(z.unknown()).optional(),
+});
+
 export async function GET(request: Request) {
   try {
     const { searchParams } = new URL(request.url);
@@ -16,10 +31,10 @@ export async function GET(request: Request) {
       nodes = nodes.filter((n) => n.direction === direction);
     }
 
-    return NextResponse.json({ 
-      nodes, 
+    return NextResponse.json({
+      nodes,
       provider: detectProvider(),
-      count: nodes.length 
+      count: nodes.length
     });
   } catch (error: unknown) {
     const message = error instanceof Error ? error.message : String(error);
@@ -29,20 +44,32 @@ export async function GET(request: Request) {
 
 export async function POST(request: Request) {
   try {
+    const body = await request.json().catch(() => null);
+    const parsed = NodeCreateSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        {
+          error: "Invalid node — nothing was created.",
+          issues: parsed.error.issues.map(
+            (issue) => `${issue.path.join(".") || "body"}: ${issue.message}`,
+          ),
+        },
+        { status: 400 },
+      );
+    }
+
     const store = await createProvider();
-    const body = await request.json();
-    
     const node = {
-      id: body.id || crypto.randomUUID(),
-      name: body.name,
-      type: body.type,
-      description: body.description || "",
-      direction: body.direction || undefined,
-      metadata: body.metadata || {},
+      id: parsed.data.id || crypto.randomUUID(),
+      name: parsed.data.name,
+      type: parsed.data.type,
+      description: parsed.data.description || "",
+      direction: parsed.data.direction,
+      metadata: parsed.data.metadata || {},
       created_at: new Date().toISOString(),
       updated_at: new Date().toISOString(),
     };
-    
+
     await store.createNode(node);
     return NextResponse.json({ success: true, node, provider: detectProvider() }, { status: 201 });
   } catch (error: unknown) {

package/app/api/plan-perspectives/[id]/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from "next/server";
+import { createProvider, detectProvider } from "@medicine-wheel/storage-provider";
+
+export async function GET(
+  _request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  try {
+    const params = await context.params;
+    const store = await createProvider();
+    const record = await store.getPlanPerspective(params.id);
+
+    if (!record) {
+      return NextResponse.json(
+        { error: `Plan Perspective '${params.id}' was not found` },
+        { status: 404 },
+      );
+    }
+
+    return NextResponse.json({
+      record,
+      provider: detectProvider(),
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/app/api/plan-perspectives/route.ts

@@ -0,0 +1,138 @@
+import { NextResponse } from "next/server";
+import {
+  createProvider,
+  detectProvider,
+  type PlanPerspectiveFilters,
+  type PlanPerspectiveRecord,
+} from "@medicine-wheel/storage-provider";
+
+const PERSPECTIVE_ID_PREFIX = "plan-perspective:";
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const filters = planPerspectiveFiltersFromSearchParams(searchParams);
+
+    if (
+      filters.episode_path === undefined &&
+      filters.session_id === undefined &&
+      filters.id === undefined
+    ) {
+      return NextResponse.json(
+        { error: "Plan Perspective queries require episode_path, session_id, or id" },
+        { status: 400 },
+      );
+    }
+
+    const store = await createProvider();
+    const planPerspectives = await store.listPlanPerspectives(filters);
+
+    return NextResponse.json({
+      plan_perspectives: planPerspectives,
+      provider: detectProvider(),
+      count: planPerspectives.length,
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  let record: PlanPerspectiveRecord;
+  try {
+    record = (await request.json()) as PlanPerspectiveRecord;
+  } catch {
+    return NextResponse.json(
+      { error: "Plan Perspective registration requires a JSON body" },
+      { status: 400 },
+    );
+  }
+
+  const validationError = validatePerspectiveRecord(record);
+  if (validationError) {
+    return NextResponse.json({ error: validationError }, { status: 400 });
+  }
+
+  try {
+    const store = await createProvider();
+    const merged = await store.registerPlanPerspective(record);
+
+    return NextResponse.json(
+      {
+        success: true,
+        record: merged,
+        provider: detectProvider(),
+      },
+      { status: 201 },
+    );
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+function planPerspectiveFiltersFromSearchParams(
+  searchParams: URLSearchParams,
+): PlanPerspectiveFilters {
+  const filters: PlanPerspectiveFilters = {};
+  const episodePath = searchParams.get("episode_path");
+  const sessionId = searchParams.get("session_id");
+  const id = searchParams.get("id");
+
+  if (episodePath) filters.episode_path = episodePath;
+  if (sessionId) filters.session_id = sessionId;
+  if (id) filters.id = id;
+
+  return filters;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Validates the PerspectiveRecord spine; unknown fields pass through untouched. */
+function validatePerspectiveRecord(record: unknown): string | null {
+  if (!isPlainObject(record)) {
+    return "Plan Perspective registration requires a PerspectiveRecord object";
+  }
+  if (!isNonEmptyString(record.id) || !record.id.startsWith(PERSPECTIVE_ID_PREFIX)) {
+    return `Plan Perspective id must be a non-empty string starting with '${PERSPECTIVE_ID_PREFIX}'`;
+  }
+  if (record.perspective !== 1) {
+    return "Plan Perspective record requires perspective: 1";
+  }
+  if (
+    !isPlainObject(record.plan) ||
+    !isNonEmptyString(record.plan.session_id) ||
+    !isNonEmptyString(record.plan.plan_filename) ||
+    !isNonEmptyString(record.plan.plan_sha256)
+  ) {
+    return "Plan Perspective record requires plan.session_id, plan.plan_filename, and plan.plan_sha256";
+  }
+  if (
+    !isPlainObject(record.narrative) ||
+    !isNonEmptyString(record.narrative.title) ||
+    typeof record.narrative.body_markdown !== "string"
+  ) {
+    return "Plan Perspective record requires narrative.title and narrative.body_markdown";
+  }
+  if (
+    !Array.isArray(record.episodes) ||
+    record.episodes.some((episode) => !isPlainObject(episode) || !isNonEmptyString(episode.path))
+  ) {
+    return "Plan Perspective episodes must be an array of { path } relations (may be empty)";
+  }
+  if (
+    !isPlainObject(record.source) ||
+    !isNonEmptyString(record.source.registered_at) ||
+    !isNonEmptyString(record.source.updated_at)
+  ) {
+    return "Plan Perspective record requires source.registered_at and source.updated_at";
+  }
+  return null;
+}

package/app/ceremonies/layout.tsx

@@ -0,0 +1,7 @@
+import type { Metadata } from "next";
+
+export const metadata: Metadata = { title: "Ceremonies" };
+
+export default function CeremoniesLayout({ children }: { children: React.ReactNode }) {
+  return children;
+}