@medicine-wheel/app 0.17.11 → 0.19.0

package/components/episode-file-tree.tsx

@@ -0,0 +1,67 @@
+/**
+ * The folders of an episode, drawn — every one open to begin with, so a file's
+ * folder is plain to see. Presentational: the panel owns which folders are
+ * closed and how a file's own row looks.
+ *
+ * @see lib/episode-file-tree.ts — how the paths are grouped and in what order
+ */
+
+import type { ReactNode } from "react";
+import type { FileTreeFolder, TreeableFile } from "@/lib/episode-file-tree";
+
+export interface EpisodeFileTreeProps<T extends TreeableFile> {
+  tree: FileTreeFolder<T>;
+  /** Paths of the folders the reader closed. Any folder not here is open. */
+  collapsed: ReadonlySet<string>;
+  onToggleFolder: (path: string) => void;
+  /** One file's row, and whatever opens beneath it. `name` is the path's last segment. */
+  renderFile: (file: T, name: string) => ReactNode;
+}
+
+export function EpisodeFileTree<T extends TreeableFile>({
+  tree,
+  collapsed,
+  onToggleFolder,
+  renderFile,
+}: EpisodeFileTreeProps<T>) {
+  return (
+    <ul className="space-y-1">
+      {tree.children.map((node) => {
+        if (node.type === "file") {
+          return <li key={node.path}>{renderFile(node.file, node.name)}</li>;
+        }
+        const isOpen = !collapsed.has(node.path);
+        return (
+          <li key={node.path} data-folder={node.path}>
+            <button
+              type="button"
+              onClick={() => onToggleFolder(node.path)}
+              aria-expanded={isOpen}
+              title={node.path}
+              className="w-full p-2 flex items-baseline gap-2 text-left text-sm font-semibold hover:underline"
+            >
+              <span aria-hidden="true" className="text-muted-foreground w-[1ch]">
+                {isOpen ? "▾" : "▸"}
+              </span>
+              <span aria-hidden="true">{isOpen ? "📂" : "📁"}</span>
+              <span className="font-mono break-all">{node.name}</span>
+              <span className="ml-auto text-xs font-normal text-muted-foreground shrink-0">
+                {node.fileCount} {node.fileCount === 1 ? "file" : "files"}
+              </span>
+            </button>
+            {isOpen && (
+              <div className="ml-4 pl-2 border-l">
+                <EpisodeFileTree
+                  tree={node}
+                  collapsed={collapsed}
+                  onToggleFolder={onToggleFolder}
+                  renderFile={renderFile}
+                />
+              </div>
+            )}
+          </li>
+        );
+      })}
+    </ul>
+  );
+}

package/components/episode-files-panel.tsx

@@ -4,6 +4,9 @@
  * An episode's folder on the episode page — listed, and any text file read in
  * place. Read-only: the wheel reads an episode, Miadi writes it.
  *
+ * Files are listed in the folders their paths name, every one open to begin
+ * with, so a reader can tell which folder a file is in.
+ *
  * Text is shown as text. Markdown is not rendered here: rendering it means a
  * renderer and a sanitizer between an episode's files and this page, and plain
  * text is already readable. Media and documents are listed, not played.
@@ -11,7 +14,9 @@
  * @see app/api/episodes/[id]/files/route.ts — and the rules it states
  */
 
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { EpisodeFileTree } from "@/components/episode-file-tree";
+import { buildFileTree, folderPaths } from "@/lib/episode-file-tree";
 
 type EpisodeFile = {
   relativePath: string;
@@ -61,6 +66,8 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
   // The path last asked for, so a slow answer for an earlier click cannot
   // replace the file the reader opened after it.
   const wanted = useRef<string | null>(null);
+  // Folders the reader closed. The tree opens fully; only a closed folder is remembered.
+  const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(new Set());
 
   useEffect(() => {
     let live = true;
@@ -99,17 +106,37 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
     [base],
   );
 
-  const files =
-    room?.state === "open"
-      ? // The episode's own work first; host and agent guidance after it.
-        [...room.files].sort((a, b) => Number(a.guidance) - Number(b.guidance))
-      : [];
+  const files = useMemo(() => (room?.state === "open" ? room.files : []), [room]);
+  const tree = useMemo(() => buildFileTree(files), [files]);
+  const folders = useMemo(() => folderPaths(tree), [tree]);
+  const allClosed = folders.length > 0 && folders.every((path) => collapsed.has(path));
+
+  const toggleFolder = useCallback(
+    (path: string) =>
+      setCollapsed((current) => {
+        const next = new Set(current);
+        if (!next.delete(path)) next.add(path);
+        return next;
+      }),
+    [],
+  );
 
   return (
     <section>
-      <h2 className="text-sm font-semibold mb-2">
-        Files {files.length > 0 && `(${files.length})`}
-      </h2>
+      <div className="flex items-baseline justify-between gap-3 mb-2">
+        <h2 className="text-sm font-semibold">
+          Files {files.length > 0 && `(${files.length})`}
+        </h2>
+        {folders.length > 0 && (
+          <button
+            type="button"
+            onClick={() => setCollapsed(allClosed ? new Set() : new Set(folders))}
+            className="text-xs text-muted-foreground hover:underline"
+          >
+            {allClosed ? "Expand all" : "Collapse all"}
+          </button>
+        )}
+      </div>
 
       {room === null ? (
         <p className="text-sm text-muted-foreground">Opening the folder…</p>
@@ -118,23 +145,30 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
       ) : files.length === 0 ? (
         <p className="text-sm text-muted-foreground">The folder holds nothing the room shows.</p>
       ) : (
-        <ul className="space-y-1">
-          {files.map((file) => {
+        <EpisodeFileTree
+          tree={tree}
+          collapsed={collapsed}
+          onToggleFolder={toggleFolder}
+          renderFile={(file, name) => {
             const isOpen = opened?.path === file.relativePath;
             return (
-              <li key={file.relativePath}>
+              <>
                 <div className="p-2 border rounded-lg bg-card flex items-baseline justify-between gap-3 flex-wrap">
                   {file.previewable ? (
                     <button
                       onClick={() => toggle(file)}
+                      title={file.relativePath}
                       className="text-sm font-mono text-left break-all hover:underline"
                       aria-expanded={isOpen}
                     >
-                      {isOpen ? "▾" : "▸"} {file.relativePath}
+                      {isOpen ? "▾" : "▸"} {name}
                     </button>
                   ) : (
-                    <span className="text-sm font-mono break-all text-muted-foreground">
-                      {file.relativePath}
+                    <span
+                      title={file.relativePath}
+                      className="text-sm font-mono break-all text-muted-foreground"
+                    >
+                      {name}
                     </span>
                   )}
                   <span className="text-xs text-muted-foreground shrink-0 flex gap-2 items-baseline">
@@ -157,10 +191,10 @@ export function EpisodeFilesPanel({ episodeId }: { episodeId: string }) {
                     )}
                   </div>
                 )}
-              </li>
+              </>
             );
-          })}
-        </ul>
+          }}
+        />
       )}
     </section>
   );

package/dist/cli/mw.js

@@ -48,6 +48,7 @@ const fs = __importStar(require("fs"));
 const skills_1 = require("./skills");
 const beats_register_1 = require("./beats-register");
 const orientation_1 = require("./orientation");
+const events_1 = require("@medicine-wheel/events");
 // ── Config ────────────────────────────────────────────────────────
 const MW_API_URL = process.env.MW_API_URL ?? 'http://localhost:8040';
 const MW_FORMAT = process.env.MW_FORMAT ?? 'pretty';
@@ -301,6 +302,15 @@ ${C.bold}🌿 mw — Medicine Wheel CLI${C.reset}
   MEMORY
     mw memory store <key> <value> [dir]   Store relational memory
 
+  EVENTS (what happened on the wheel, kept in events.jsonl)
+    mw events [--type cycle.] [--subject <id>] [--correlation <id>]
+              [--since <iso>] [--limit 20]  List events, newest first
+    mw events status                       What the publisher still owes
+    mw events publish                      Send what waits now
+    mw events replay <event-id|all>        Send again from that event
+    mw events sync                         Commit (and push) events.jsonl now
+    mw events schema [--asyncapi]          Print the JSON Schema (or AsyncAPI)
+
   SYSTEM
     mw status                              Show system status
     mw tools                               List all MCP tools
@@ -758,6 +768,95 @@ function cmdMemory(positional) {
             unknownSub('memory', sub, ['store']);
     }
 }
+async function eventsApi(method, urlPath, body) {
+    const res = await fetch(`${MW_API_URL}${urlPath}`, {
+        method,
+        headers: { 'Content-Type': 'application/json' },
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+    });
+    return { status: res.status, data: (await res.json().catch(() => ({}))) };
+}
+function printEvent(e) {
+    const when = e.observed_at.replace('T', ' ').slice(0, 19);
+    const payload = e.payload;
+    const changed = Array.isArray(payload.changed) ? ` ${C.dim}changed ${payload.changed.join(', ')}${C.reset}` : '';
+    const corr = e.correlation_id && e.correlation_id !== e.subject.id ? ` ${C.dim}↳ ${e.correlation_id}${C.reset}` : '';
+    console.log(`  ${C.dim}${when}${C.reset}  ${C.bold}${(0, events_1.shortName)(e.event_type)}${C.reset}  ${e.subject.kind} ${e.subject.id}${changed}${corr}`);
+}
+async function cmdEvents(positional, flags) {
+    const sub = positional[0] ?? 'list';
+    const failed = (status, data) => {
+        console.error(`${C.south}${data?.error ?? `HTTP ${status}`}${C.reset}`);
+        if (data?.hint)
+            console.error(`  ${data.hint}`);
+        process.exitCode = 1;
+    };
+    switch (sub) {
+        case 'list': {
+            const params = new URLSearchParams();
+            for (const key of ['type', 'subject', 'correlation', 'since', 'limit']) {
+                const value = flags[key];
+                if (typeof value === 'string')
+                    params.set(key, value);
+            }
+            if (!params.has('limit'))
+                params.set('limit', '20');
+            const { status, data } = await eventsApi('GET', `/api/events?${params}`);
+            if (status !== 200)
+                return failed(status, data);
+            if (MW_FORMAT !== 'pretty')
+                return ppValue(data);
+            const events = data.events ?? [];
+            console.log(`${C.bold}${events.length} of ${data.total ?? events.length} event(s)${C.reset}`);
+            for (const e of events)
+                printEvent(e);
+            break;
+        }
+        case 'status': {
+            const { status, data } = await eventsApi('GET', '/api/events/publish');
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            break;
+        }
+        case 'publish': {
+            const { status, data } = await eventsApi('POST', '/api/events/publish', {});
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            if (data.stopped)
+                process.exitCode = 1;
+            break;
+        }
+        case 'replay': {
+            const from = positional[1];
+            if (!from) {
+                console.error(`${C.south}mw events replay needs an event id, or "all"${C.reset}`);
+                process.exitCode = EXIT_USAGE;
+                return;
+            }
+            const { status, data } = await eventsApi('POST', '/api/events/publish', { replay_from: from });
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            if (data.stopped)
+                process.exitCode = 1;
+            break;
+        }
+        case 'sync': {
+            const { status, data } = await eventsApi('POST', '/api/events/git');
+            if (status !== 200)
+                return failed(status, data);
+            ppValue(data);
+            break;
+        }
+        case 'schema':
+            console.log(JSON.stringify(flags['asyncapi'] ? (0, events_1.asyncApiDocument)() : (0, events_1.wheelEventsJsonSchema)(), null, 2));
+            break;
+        default:
+            unknownSub('events', sub, ['list', 'status', 'publish', 'replay', 'sync', 'schema']);
+    }
+}
 // ── Main dispatch ─────────────────────────────────────────────────
 async function main() {
     const { flags, positional } = parseArgs(process.argv);
@@ -824,6 +923,10 @@ async function main() {
         case 'mem':
             cmdMemory(rest);
             break;
+        case 'events':
+        case 'ev':
+            await cmdEvents(rest, flags);
+            break;
         case 'skill':
         case 'sk':
             cmdSkill(rest);

package/instrumentation.ts

@@ -4,9 +4,20 @@
  * Starts the Honcho river's retry clock (#147): records Honcho could not
  * receive while it was away wait on the pending ledger, and are sent again on
  * start and every few minutes after. With `HONCHO_URL` unset this does nothing.
+ *
+ * Starts the event publisher's clock (#164): events in `events.jsonl` that the
+ * configured publisher has not taken are sent on start and every minute after.
+ * With `MW_EVENTS_PUBLISH_URL` unset this does nothing.
+ *
+ * Starts the event log's git carriage (#164): with `MW_EVENTS_GIT_SYNC` set,
+ * `events.jsonl` is committed in its data repository (and pushed) on start
+ * and every ten minutes, besides soon after each recorded event.
  */
 export async function register() {
   if (process.env.NEXT_RUNTIME !== "nodejs") return;
   const { startPendingRetries } = await import("@/lib/honcho-projection");
   startPendingRetries();
+  const { startEventPublishing, startEventGitSync } = await import("@/lib/event-log");
+  startEventPublishing();
+  startEventGitSync();
 }

package/lib/episode-file-tree.ts

@@ -0,0 +1,135 @@
+/**
+ * An episode's files, grouped into the folders their paths name.
+ *
+ * `listEpisodeFiles` returns files with the path each sits at, and no folders,
+ * so the Files section printed whole paths one under another and a reader could
+ * not tell which folder a file was in. This builds the folders back from the
+ * paths, so the panel can draw them.
+ *
+ * This is layout, not a rule about what an episode shows — those live in
+ * `@miadi/episode-vessel` and in `lib/episode-files.ts`, and nothing here
+ * decides what may be listed or read. The same grouping is drawn in Miadi's room
+ * by `@miadi/episode-ui` (`buildFileTree`); the wheel keeps its own small copy
+ * until it takes that package, and the two are meant to agree on order:
+ *
+ *  1. a `README.md`;
+ *  2. the folders, by name;
+ *  3. the files — text, documents, guidance, then media — by name.
+ *
+ * Names compare numerically, so `chapter-2` comes before `chapter-10`.
+ */
+
+/** The part of a listed file the grouping reads. Any richer shape passes through untouched. */
+export interface TreeableFile {
+  relativePath: string;
+  name: string;
+  kind: string;
+  guidance: boolean;
+}
+
+export interface FileTreeFile<T extends TreeableFile> {
+  type: "file";
+  /** The last segment of the path. */
+  name: string;
+  path: string;
+  file: T;
+}
+
+export interface FileTreeFolder<T extends TreeableFile> {
+  type: "folder";
+  /** The last segment of the path. Empty for the root. */
+  name: string;
+  /** The path from the episode root. Empty for the root. */
+  path: string;
+  children: FileTreeNode<T>[];
+  /** Every file beneath this folder, at any depth. */
+  fileCount: number;
+}
+
+export type FileTreeNode<T extends TreeableFile> = FileTreeFile<T> | FileTreeFolder<T>;
+
+const compareNames = (left: string, right: string): number =>
+  left.localeCompare(right, undefined, { numeric: true, sensitivity: "base" }) ||
+  (left < right ? -1 : left > right ? 1 : 0);
+
+function rank(file: TreeableFile): number {
+  if (/^README\.md$/i.test(file.name)) return 0;
+  if (file.guidance) return 3;
+  if (file.kind === "text") return 1;
+  if (file.kind === "document") return 2;
+  return 4;
+}
+
+function order<T extends TreeableFile>(folder: FileTreeFolder<T>): void {
+  const folders = folder.children.filter((n): n is FileTreeFolder<T> => n.type === "folder");
+  const files = folder.children.filter((n): n is FileTreeFile<T> => n.type === "file");
+  folders.sort((a, b) => compareNames(a.name, b.name));
+  files.sort((a, b) => rank(a.file) - rank(b.file) || compareNames(a.name, b.name));
+  folder.children = [
+    ...files.filter((n) => rank(n.file) === 0),
+    ...folders,
+    ...files.filter((n) => rank(n.file) !== 0),
+  ];
+  folders.forEach(order);
+}
+
+/**
+ * Group `files` into folders by path. A path listed twice is kept once, and a
+ * folder exists only because a file is beneath it.
+ */
+export function buildFileTree<T extends TreeableFile>(files: readonly T[]): FileTreeFolder<T> {
+  const root: FileTreeFolder<T> = { type: "folder", name: "", path: "", children: [], fileCount: 0 };
+  const folders = new Map<string, FileTreeFolder<T>>([["", root]]);
+  const seen = new Set<string>();
+
+  const folderAt = (path: string): FileTreeFolder<T> => {
+    const known = folders.get(path);
+    if (known) return known;
+    const cut = path.lastIndexOf("/");
+    const parent = folderAt(cut === -1 ? "" : path.slice(0, cut));
+    const created: FileTreeFolder<T> = {
+      type: "folder",
+      name: cut === -1 ? path : path.slice(cut + 1),
+      path,
+      children: [],
+      fileCount: 0,
+    };
+    folders.set(path, created);
+    parent.children.push(created);
+    return created;
+  };
+
+  for (const file of files) {
+    if (seen.has(file.relativePath)) continue;
+    seen.add(file.relativePath);
+    const cut = file.relativePath.lastIndexOf("/");
+    const parent = folderAt(cut === -1 ? "" : file.relativePath.slice(0, cut));
+    parent.children.push({
+      type: "file",
+      name: cut === -1 ? file.relativePath : file.relativePath.slice(cut + 1),
+      path: file.relativePath,
+      file,
+    });
+    for (let path = parent.path; ; path = path.slice(0, Math.max(path.lastIndexOf("/"), 0))) {
+      folders.get(path)!.fileCount += 1;
+      if (!path) break;
+    }
+  }
+
+  order(root);
+  return root;
+}
+
+/** Every folder path in the tree, outermost first. The root is not one. */
+export function folderPaths<T extends TreeableFile>(tree: FileTreeFolder<T>): string[] {
+  const paths: string[] = [];
+  const walk = (folder: FileTreeFolder<T>) => {
+    for (const child of folder.children) {
+      if (child.type !== "folder") continue;
+      paths.push(child.path);
+      walk(child);
+    }
+  };
+  walk(tree);
+  return paths;
+}