@walwal-harness/cli 7.1.39 → 7.1.41

package/apps/harness-dashboard/lib/markdown.tsx

@@ -1,306 +0,0 @@
-"use client";
-import React from "react";
-
-// ---------------------------------------------------------------------------
-// Inline renderer — handles **bold**, `code`, *italic*
-// ---------------------------------------------------------------------------
-function renderInline(text: string): React.ReactNode[] {
-  const parts: React.ReactNode[] = [];
-  // Pattern order matters: bold, inline-code, italic
-  const re = /(\*\*(.+?)\*\*|`(.+?)`|\*(.+?)\*)/g;
-  let last = 0;
-  let match: RegExpExecArray | null;
-  let key = 0;
-
-  while ((match = re.exec(text)) !== null) {
-    if (match.index > last) {
-      parts.push(text.slice(last, match.index));
-    }
-    if (match[0].startsWith("**")) {
-      parts.push(
-        <strong key={key++} className="text-white font-semibold">
-          {match[2]}
-        </strong>
-      );
-    } else if (match[0].startsWith("`")) {
-      parts.push(
-        <code
-          key={key++}
-          className="bg-gray-800 text-amber-300 text-[11px] px-1 rounded"
-        >
-          {match[3]}
-        </code>
-      );
-    } else {
-      parts.push(
-        <em key={key++} className="italic text-gray-300">
-          {match[4]}
-        </em>
-      );
-    }
-    last = match.index + match[0].length;
-  }
-  if (last < text.length) parts.push(text.slice(last));
-  return parts;
-}
-
-// ---------------------------------------------------------------------------
-// Table renderer
-// ---------------------------------------------------------------------------
-function renderTable(rows: string[]): React.ReactNode {
-  // rows[0] = header, rows[1] = separator, rows[2+] = data
-  const parseRow = (row: string): string[] =>
-    row
-      .split("|")
-      .map((c) => c.trim())
-      .filter((_, i, arr) => i > 0 && i < arr.length - 1);
-
-  const headers = parseRow(rows[0]);
-  const dataRows = rows.slice(2).map(parseRow);
-
-  return (
-    <div key={Math.random()} className="overflow-x-auto">
-      <table className="w-full border-collapse font-mono text-[11px]">
-        <thead>
-          <tr>
-            {headers.map((h, i) => (
-              <th
-                key={i}
-                className="border border-gray-700/60 bg-gray-800/50 px-2 py-1 text-left text-cyan-300/90"
-              >
-                {renderInline(h)}
-              </th>
-            ))}
-          </tr>
-        </thead>
-        <tbody>
-          {dataRows.map((row, ri) => (
-            <tr key={ri} className="border-b border-gray-700/40">
-              {row.map((cell, ci) => (
-                <td
-                  key={ci}
-                  className="border border-gray-700/40 px-2 py-1 text-gray-300"
-                >
-                  {renderInline(cell)}
-                </td>
-              ))}
-            </tr>
-          ))}
-        </tbody>
-      </table>
-    </div>
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Block renderer state machine
-// ---------------------------------------------------------------------------
-function renderBlocks(content: string): React.ReactNode[] {
-  const lines = content.split("\n");
-  const nodes: React.ReactNode[] = [];
-  let i = 0;
-  let keyCounter = 0;
-  const k = () => keyCounter++;
-
-  while (i < lines.length) {
-    const line = lines[i];
-
-    // ---- Fenced code block ----
-    if (line.startsWith("```")) {
-      const lang = line.slice(3).trim();
-      const codeLines: string[] = [];
-      i++;
-      while (i < lines.length && !lines[i].startsWith("```")) {
-        codeLines.push(lines[i]);
-        i++;
-      }
-      i++; // skip closing ```
-      nodes.push(
-        <pre
-          key={k()}
-          className="overflow-x-auto rounded border border-gray-700/60 bg-[#0d1117] p-3 my-2"
-        >
-          <code className="text-emerald-300/90 text-[11px] font-mono whitespace-pre">
-            {lang ? (
-              <span className="block text-[10px] text-gray-600 mb-1">{lang}</span>
-            ) : null}
-            {codeLines.join("\n")}
-          </code>
-        </pre>
-      );
-      continue;
-    }
-
-    // ---- HR ----
-    if (/^---+$/.test(line.trim())) {
-      nodes.push(<hr key={k()} className="border-gray-700/50 my-3" />);
-      i++;
-      continue;
-    }
-
-    // ---- H1 ----
-    if (line.startsWith("# ")) {
-      nodes.push(
-        <h1 key={k()} className="text-[16px] font-bold text-white mt-3 mb-1">
-          {renderInline(line.slice(2))}
-        </h1>
-      );
-      i++;
-      continue;
-    }
-
-    // ---- H2 ----
-    if (line.startsWith("## ")) {
-      nodes.push(
-        <h2
-          key={k()}
-          className="text-[13px] font-bold text-cyan-300/90 mt-4 mb-0.5 pb-0.5 border-b border-gray-700/40"
-        >
-          {renderInline(line.slice(3))}
-        </h2>
-      );
-      i++;
-      continue;
-    }
-
-    // ---- H3 ----
-    if (line.startsWith("### ")) {
-      nodes.push(
-        <h3 key={k()} className="text-[12px] font-semibold text-gray-200 mt-3 mb-0.5">
-          {renderInline(line.slice(4))}
-        </h3>
-      );
-      i++;
-      continue;
-    }
-
-    // ---- H4 ----
-    if (line.startsWith("#### ")) {
-      nodes.push(
-        <h4 key={k()} className="text-[11px] font-semibold text-gray-300 mt-2 mb-0.5">
-          {renderInline(line.slice(5))}
-        </h4>
-      );
-      i++;
-      continue;
-    }
-
-    // ---- Table ----
-    if (line.includes("|") && i + 1 < lines.length && /^\|?[\s\-:|]+\|/.test(lines[i + 1])) {
-      const tableRows: string[] = [line];
-      i++;
-      while (i < lines.length && lines[i].includes("|")) {
-        tableRows.push(lines[i]);
-        i++;
-      }
-      if (tableRows.length >= 2) {
-        nodes.push(
-          <div key={k()} className="my-2">
-            {renderTable(tableRows)}
-          </div>
-        );
-      }
-      continue;
-    }
-
-    // ---- Checkbox list items ----
-    if (/^- \[x\]/i.test(line)) {
-      nodes.push(
-        <div key={k()} className="flex items-start gap-1.5 text-[12px] text-gray-300 pl-2">
-          <span className="text-emerald-400 shrink-0">✓</span>
-          <span>{renderInline(line.slice(6).trim())}</span>
-        </div>
-      );
-      i++;
-      continue;
-    }
-    if (/^- \[ \]/.test(line)) {
-      nodes.push(
-        <div key={k()} className="flex items-start gap-1.5 text-[12px] text-gray-400 pl-2">
-          <span className="text-gray-600 shrink-0">○</span>
-          <span>{renderInline(line.slice(6).trim())}</span>
-        </div>
-      );
-      i++;
-      continue;
-    }
-
-    // ---- Bullet list ----
-    if (/^(\s*)([-*])\s/.test(line)) {
-      const listItems: React.ReactNode[] = [];
-      while (i < lines.length && /^(\s*)([-*])\s/.test(lines[i])) {
-        const indent = lines[i].match(/^(\s*)/)?.[1].length ?? 0;
-        const text = lines[i].replace(/^\s*[-*]\s/, "");
-        listItems.push(
-          <li
-            key={k()}
-            style={{ paddingLeft: indent > 0 ? `${indent * 8}px` : undefined }}
-            className="flex items-start gap-1.5"
-          >
-            <span className="text-gray-600 shrink-0 mt-0.5">•</span>
-            <span>{renderInline(text)}</span>
-          </li>
-        );
-        i++;
-      }
-      nodes.push(
-        <ul key={k()} className="space-y-0.5 text-[12px] text-gray-300 my-1">
-          {listItems}
-        </ul>
-      );
-      continue;
-    }
-
-    // ---- Numbered list ----
-    if (/^\d+\.\s/.test(line)) {
-      const listItems: React.ReactNode[] = [];
-      let num = 1;
-      while (i < lines.length && /^\d+\.\s/.test(lines[i])) {
-        const text = lines[i].replace(/^\d+\.\s/, "");
-        listItems.push(
-          <li key={k()} className="flex items-start gap-1.5">
-            <span className="text-gray-500 shrink-0 tabular-nums">{num}.</span>
-            <span>{renderInline(text)}</span>
-          </li>
-        );
-        i++;
-        num++;
-      }
-      nodes.push(
-        <ol key={k()} className="space-y-0.5 text-[12px] text-gray-300 my-1">
-          {listItems}
-        </ol>
-      );
-      continue;
-    }
-
-    // ---- Blank line ----
-    if (line.trim() === "") {
-      i++;
-      continue;
-    }
-
-    // ---- Regular paragraph ----
-    nodes.push(
-      <p key={k()} className="text-gray-300 text-[12px] leading-relaxed">
-        {renderInline(line)}
-      </p>
-    );
-    i++;
-  }
-
-  return nodes;
-}
-
-// ---------------------------------------------------------------------------
-// Public component
-// ---------------------------------------------------------------------------
-export function MarkdownView({ source }: { source: string }) {
-  // Strip YAML frontmatter (between --- ... ---)
-  const content = source.replace(/^---[\s\S]*?---\n+/, "").trim();
-  return (
-    <div className="space-y-1.5 text-[12px] leading-relaxed">
-      {renderBlocks(content)}
-    </div>
-  );
-}

package/apps/harness-dashboard/lib/path-planning.ts

@@ -1,72 +0,0 @@
-import { ROOM_RECTS, CORRIDOR_RECTS } from "./iso";
-import { doorsForRoom } from "./furniture";
-import type { RoomId } from "./types";
-
-export type Zone = RoomId | "corridor" | "outdoor";
-
-export function zoneAt(x: number, z: number): Zone {
-  for (const r of ROOM_RECTS) {
-    if (x >= r.wx && x <= r.wx + r.ww && z >= r.wy && z <= r.wy + r.wh) {
-      return r.id;
-    }
-  }
-  for (const c of CORRIDOR_RECTS) {
-    if (x >= c.wx && x <= c.wx + c.ww && z >= c.wy && z <= c.wy + c.wh) {
-      return "corridor";
-    }
-  }
-  return "outdoor";
-}
-
-// Returns the corridor-side foot of the room's primary door — i.e. a point
-// just outside the wall, so a minifig walking to it leaves the room cleanly
-// through the door opening.
-export function exitWaypoint(roomId: RoomId): [number, number] | null {
-  const rect = ROOM_RECTS.find((r) => r.id === roomId);
-  if (!rect) return null;
-  const doors = doorsForRoom(rect);
-  if (doors.length === 0) return null;
-  // Pick the door that points "down" (toward south corridor) when available;
-  // it gives the most natural look because all rooms have a south or north
-  // corridor adjacency.
-  const preferred =
-    doors.find((d) => d.side === "south") ??
-    doors.find((d) => d.side === "north") ??
-    doors[0];
-  const offset = 0.6;
-  switch (preferred.side) {
-    case "north":
-      return [preferred.position[0], preferred.position[1] - offset];
-    case "south":
-      return [preferred.position[0], preferred.position[1] + offset];
-    case "east":
-      return [preferred.position[0] + offset, preferred.position[1]];
-    case "west":
-      return [preferred.position[0] - offset, preferred.position[1]];
-  }
-}
-
-// Plans a wall-respecting path from `from` to `to`.
-// Rule: leaving a room or entering a room must pass through that room's door.
-// Movement within the same zone (or between corridor / outdoor) is direct.
-export function planPath(
-  from: [number, number],
-  to: [number, number]
-): Array<[number, number]> {
-  const fromZone = zoneAt(from[0], from[1]);
-  const toZone = zoneAt(to[0], to[1]);
-  const waypoints: Array<[number, number]> = [];
-
-  const isRoom = (z: Zone): z is RoomId => z !== "corridor" && z !== "outdoor";
-
-  if (isRoom(fromZone) && fromZone !== toZone) {
-    const exit = exitWaypoint(fromZone);
-    if (exit) waypoints.push(exit);
-  }
-  if (isRoom(toZone) && fromZone !== toZone) {
-    const entry = exitWaypoint(toZone);
-    if (entry) waypoints.push(entry);
-  }
-  waypoints.push(to);
-  return waypoints;
-}

package/apps/harness-dashboard/lib/state-mapping.ts

@@ -1,146 +0,0 @@
-import type { AgentId, Dept, MinifigState } from "./types";
-
-const AGENT_ALIASES: Record<string, AgentId[]> = {
-  ceo: ["dispatcher", "brainstormer"],
-  dispatcher: ["dispatcher"],
-  brainstormer: ["brainstormer"],
-  coo: ["planner", "coo-developer", "documentationer"],
-  planner: ["planner"],
-  cdo: ["generator-designer"],
-  cto: ["cto", "conductor", "generator-backend", "generator-frontend", "generator-designer", "generator-devops"],
-  cqo: ["cqo", "evaluator-functional", "evaluator-visual", "evaluator-code-quality", "evaluator-architecture", "evaluator-security"],
-  ops: ["service-ops"],
-  "service-ops": ["service-ops"],
-};
-
-export interface ProgressSlice {
-  current_agent?: string | null;
-  next_agent?: string | null;
-  agent_status?: string;
-  failure?: { agent?: string | null; message?: string | null } | null;
-  meetings?: { active?: string[] };
-  service_ops?: {
-    incident?: { open?: Array<{ id: string; dept?: string }> };
-    monitor?: { stream_active?: boolean; stream_target?: string | null };
-    requested_mode?: string | null;
-  };
-  // v6 NEXUS parallel mode (CLAUDE.md §Parallel Tracks). When tracks have
-  // owners with status=running, those agents are concurrently working —
-  // not just current_agent. The dashboard treats every running owner as
-  // typing so the parallel reality is visible.
-  conductor?: {
-    state?: string;
-    current_action?: string | null;
-    tracks?: Array<{ owner?: string; status?: string }>;
-  };
-}
-
-export interface DeriveContext {
-  // Distinct departments with at least one open incident — pre-computed by
-  // harness-state.ts so the mapping doesn't iterate the array per agent.
-  incidentDepts?: Set<string>;
-  // The agent's own department (passed in because we map by department, not
-  // by the bare AgentId).
-  dept?: Dept | "Operations";
-}
-
-// `conductor.current_action` carries strings like:
-//   "spawn:generator-frontend"
-//   "spawn:coo-developer:F12-006"
-//   "spawn:generator-backend (foundation F-101)"
-// Pull out the agent id from the head.
-export function parseSpawnAgent(action: string | null | undefined): string | null {
-  if (!action) return null;
-  const m = /^spawn:([a-z][a-z0-9-]*)/i.exec(action);
-  return m ? m[1].toLowerCase() : null;
-}
-
-function agentMatches(agentId: string, raw: string | null | undefined): boolean {
-  if (!raw) return false;
-  const key = raw.toLowerCase();
-  if (key === agentId) return true;
-  return AGENT_ALIASES[key]?.includes(agentId as AgentId) ?? false;
-}
-
-function isAgentRunningTrack(
-  agentId: string,
-  conductor: ProgressSlice["conductor"]
-): boolean {
-  const tracks = conductor?.tracks ?? [];
-  return tracks.some(
-    (t) =>
-      agentMatches(agentId, t.owner) &&
-      (t.status === "running" || t.status === "in_progress" || t.status === "active")
-  );
-}
-
-function isAgentQueuedTrack(
-  agentId: string,
-  conductor: ProgressSlice["conductor"]
-): boolean {
-  const tracks = conductor?.tracks ?? [];
-  return tracks.some((t) => agentMatches(agentId, t.owner) && t.status === "pending");
-}
-
-// Priority: red-alert > talking > typing > queued > idle.
-// red-alert wins because incidents/failures must dominate the visual field.
-// talking wins over typing because meetings teleport overrides desk presence.
-// typing now reflects v6 NEXUS *parallel* mode — multiple agents can be
-// concurrently working, all of them get the typing aura.
-// queued makes autonomous handoff visible: when the company already assigned
-// a next department, that department sits at its desk even before the worker
-// process emits its first log line.
-export function deriveMinifigState(
-  agentId: AgentId,
-  progress: ProgressSlice | null,
-  ctx: DeriveContext = {}
-): MinifigState {
-  if (!progress) return "idle";
-  if (agentMatches(agentId, progress.failure?.agent)) return "red-alert";
-  if (ctx.dept && ctx.incidentDepts && ctx.incidentDepts.size > 0) {
-    if (ctx.dept === "Operations" || ctx.incidentDepts.has(ctx.dept)) {
-      return "red-alert";
-    }
-  }
-  const inMeeting = progress.meetings?.active?.some((id) => agentMatches(agentId, id)) ?? false;
-  if (inMeeting) return "talking";
-
-  // Parallel-typing signals (any one of these means the agent is working).
-  if (
-    agentMatches(agentId, progress.current_agent) &&
-    progress.agent_status === "running"
-  ) {
-    return "typing";
-  }
-  if (isAgentRunningTrack(agentId, progress.conductor)) {
-    return "typing";
-  }
-  if (agentMatches(agentId, parseSpawnAgent(progress.conductor?.current_action))) {
-    return "typing";
-  }
-  // G-006: service-ops co-spawned in monitor mode is actively streaming.
-  if (
-    agentId === "service-ops" &&
-    progress.service_ops?.monitor?.stream_active === true
-  ) {
-    return "typing";
-  }
-  if (
-    agentMatches(agentId, progress.next_agent) &&
-    progress.agent_status !== "blocked" &&
-    progress.agent_status !== "failed"
-  ) {
-    return "queued";
-  }
-  if (isAgentQueuedTrack(agentId, progress.conductor)) {
-    return "queued";
-  }
-
-  return "idle";
-}
-
-export function pickTalkingPreview(agentId: AgentId): string {
-  // Sprint 2 will pull this from progress.log; for Sprint 1 we surface a stub
-  // so the speech-bubble component has a sensible default.
-  return `${agentId}…`;
-}