@medicine-wheel/app 0.4.13 → 0.5.1

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/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;
+}

package/app/ceremonies/page.tsx

@@ -3,11 +3,14 @@
 import { useCallback, useEffect, useState, Suspense, useMemo } from "react";
 import type { FormEvent } from "react";
 import { useSearchParams } from "next/navigation";
-import { type CeremonyLog, DIRECTION_COLORS, CEREMONY_ICONS, type DirectionName, type CeremonyType } from "@/lib/types";
+import { type CeremonyLog, CEREMONY_ICONS, type DirectionName, type CeremonyType } from "@/lib/types";
 import { extractCeremonyLogs } from "@/lib/ceremony-response";
 import { relativeTime, absoluteTime } from "@/lib/format-time";
 import { toast } from "sonner";
 
+const dirVar = (d: string) => `var(--mw-${d})`;
+const dirInk = (d: string) => `var(--mw-${d}-ink)`;
+
 function CeremoniesContent() {
   const searchParams = useSearchParams();
   const [ceremonies, setCeremonies] = useState<CeremonyLog[]>([]);
@@ -58,7 +61,7 @@ function CeremoniesContent() {
       toast.success("Ceremony logged");
       setShowForm(false);
       await loadCeremonies();
-    } else { toast.error("Failed to log ceremony"); }
+    } else { toast.error("Could not save the ceremony — check the form and try again"); }
   }
 
   const directions: DirectionName[] = ["east", "south", "west", "north"];
@@ -73,10 +76,10 @@ function CeremoniesContent() {
   }, [ceremonies]);
 
   const phaseFramings: Record<string, string> = {
-    opening: "🔥 We are in the Opening phase — setting intentions and acknowledging relationships",
-    council: "🔥 We are in the Council phase — deepening understanding through dialogue",
-    integration: "🔥 We are in the Integration phase — weaving learnings together",
-    closure: "🔥 We are in the Closure phase — honoring what has been shared",
+    opening: "We are in the Opening phase — setting intentions and acknowledging relationships",
+    council: "We are in the Council phase — deepening understanding through dialogue",
+    integration: "We are in the Integration phase — weaving learnings together",
+    closure: "We are in the Closure phase — honoring what has been shared",
   };
   const phases = ["opening", "council", "integration", "closure"];
   const nextPhase = phases[(phases.indexOf(currentPhase) + 1) % 4];
@@ -85,10 +88,10 @@ function CeremoniesContent() {
     <div className="p-6 max-w-5xl mx-auto">
       <div className="flex items-center justify-between mb-6">
         <div>
-          <h1 className="text-2xl font-bold">Ceremonies</h1>
+          <h1 className="mw-h1">Ceremonies</h1>
           <p className="text-sm text-muted-foreground">{ceremonies.length} ceremony logs</p>
         </div>
-        <button onClick={() => setShowForm(!showForm)} className="px-4 py-1.5 rounded-md bg-primary text-primary-foreground text-sm font-medium">+ Log Ceremony</button>
+        <button onClick={() => setShowForm(!showForm)} className="px-4 py-1.5 rounded-md bg-primary text-primary-foreground text-sm font-medium hover:opacity-90">Log ceremony</button>
       </div>
 
       <div className="mb-6 p-4 rounded-lg border bg-card/50 backdrop-blur">
@@ -110,13 +113,13 @@ function CeremoniesContent() {
         <div className="flex gap-1">
           <button onClick={() => setFilterDir("all")} className={`px-3 py-1 rounded-full text-xs font-medium border ${filterDir === "all" ? "bg-secondary" : ""}`}>All</button>
           {directions.map((d) => (
-            <button key={d} onClick={() => setFilterDir(d)} className={`px-3 py-1 rounded-full text-xs font-medium border capitalize ${filterDir === d ? "bg-secondary" : ""}`} style={filterDir === d ? { borderColor: DIRECTION_COLORS[d] } : {}}>
+            <button key={d} onClick={() => setFilterDir(d)} className={`px-3 py-1 rounded-full text-xs font-medium border capitalize hover:bg-secondary/60 ${filterDir === d ? "bg-secondary" : ""}`} style={filterDir === d ? { borderColor: dirVar(d) } : {}}>
               {d}
             </button>
           ))}
         </div>
         <select value={filterType} onChange={(e) => setFilterType(e.target.value)} className="px-3 py-1 rounded-md border bg-background text-xs">
-          <option value="all">All Types</option>
+          <option value="all">All types</option>
           {cTypes.map((t) => <option key={t} value={t}>{t.replace("_", " ")}</option>)}
         </select>
         {filtersActive && (
@@ -136,7 +139,7 @@ function CeremoniesContent() {
           <input name="medicines" placeholder="Medicines used (comma-separated)" className="px-3 py-2 rounded-md border bg-background text-sm" />
           <textarea name="intention" placeholder="Intention" rows={2} className="px-3 py-2 rounded-md border bg-background text-sm sm:col-span-2" />
           <input name="context" placeholder="Research context (optional)" className="px-3 py-2 rounded-md border bg-background text-sm" />
-          <button type="submit" className="px-4 py-2 rounded-md bg-primary text-primary-foreground text-sm">Log Ceremony</button>
+          <button type="submit" className="px-4 py-2 rounded-md bg-primary text-primary-foreground text-sm hover:opacity-90">Log ceremony</button>
         </form>
       )}
 
@@ -144,13 +147,13 @@ function CeremoniesContent() {
         {loading && <div className="text-center py-12 text-muted-foreground">Loading ceremonies…</div>}
         {!loading && ceremonies.length === 0 && (
           <div className="text-center py-12 text-muted-foreground">
-            <p>{filtersActive ? "No ceremonies match these filters." : "No ceremonies found. Log your first ceremony to begin."}</p>
+            <p>{filtersActive ? "No ceremonies match these filters." : "No ceremonies yet. Log the first one to open the circle."}</p>
             {filtersActive && <button onClick={clearFilters} className="text-sm mt-2 underline hover:text-foreground">Clear filters</button>}
           </div>
         )}
         {!loading && ceremonies.map((c) => (
           <div key={c.id} className="border rounded-lg bg-card overflow-hidden cursor-pointer hover:border-ring/50 transition-colors"
-            style={{ borderTopColor: DIRECTION_COLORS[c.direction], borderTopWidth: 3 }} onClick={() => setExpandedId(expandedId === c.id ? null : c.id)}>
+            style={{ borderTopColor: dirVar(c.direction), borderTopWidth: 3 }} onClick={() => setExpandedId(expandedId === c.id ? null : c.id)}>
             <div className="p-4 flex items-center justify-between gap-3">
               <div className="flex items-center gap-3 min-w-0">
                 <span className="text-2xl shrink-0">{CEREMONY_ICONS[c.type]}</span>
@@ -158,7 +161,7 @@ function CeremoniesContent() {
                   <div className="flex items-center gap-2">
                     <span className="font-medium text-sm capitalize">{c.type.replace("_", " ")}</span>
                     <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[11px] font-medium capitalize border"
-                      style={{ borderColor: DIRECTION_COLORS[c.direction], color: DIRECTION_COLORS[c.direction] }}>
+                      style={{ borderColor: `var(--mw-${c.direction}-border)`, color: dirInk(c.direction) }}>
                       {DIRECTION_ICONS[c.direction]} {c.direction}
                     </span>
                   </div>