@jkwd/inbase 0.1.12 → 0.1.13

package/apps/explorer/src/scene/walkLod.ts

@@ -0,0 +1,201 @@
+import { CONFIG } from '../theme'
+import type { PlacedBridge, PlacedFile, PlacedFolder } from '../types'
+
+export const WALK_MESH_RADIUS = 120
+export const WALK_MESH_KEEP = 148
+export const WALK_LABEL_RADIUS = 28
+export const WALK_LABEL_KEEP = 36
+export const WALK_FOLDER_PAD = 160
+export const WALK_FOLDER_LABEL = 18
+export const WALK_AROUND = 14
+export const WALK_BEHIND_DOT = -0.18
+
+export type WalkLod = {
+  files: Set<string>
+  labels: Set<string>
+  folders: Set<string>
+  folderLabels: Set<string>
+  bridges: Set<string>
+}
+
+export function folderDistance(
+  px: number,
+  pz: number,
+  folder: PlacedFolder,
+): number {
+  const halfW = folder.width / 2
+  const minX = folder.x - halfW
+  const maxX = folder.x + halfW
+  const minZ = folder.z
+  const maxZ = folder.z + folder.depth
+  const cx = Math.min(maxX, Math.max(minX, px))
+  const cz = Math.min(maxZ, Math.max(minZ, pz))
+  return Math.hypot(px - cx, pz - cz)
+}
+
+function distanceToSegment(
+  px: number,
+  pz: number,
+  ax: number,
+  az: number,
+  bx: number,
+  bz: number,
+) {
+  const dx = bx - ax
+  const dz = bz - az
+  const lengthSq = dx * dx + dz * dz
+  if (lengthSq === 0) return Math.hypot(px - ax, pz - az)
+  const t = Math.max(0, Math.min(1, ((px - ax) * dx + (pz - az) * dz) / lengthSq))
+  return Math.hypot(px - (ax + dx * t), pz - (az + dz * t))
+}
+
+function bridgeDistance(
+  px: number,
+  pz: number,
+  bridge: PlacedBridge,
+): number {
+  let nearest = Infinity
+  for (let i = 1; i < bridge.points.length; i += 1) {
+    const from = bridge.points[i - 1]
+    const to = bridge.points[i]
+    nearest = Math.min(
+      nearest,
+      distanceToSegment(px, pz, from[0], from[1], to[0], to[1]),
+    )
+  }
+  if (!Number.isFinite(nearest) && bridge.points[0]) {
+    return Math.hypot(px - bridge.points[0][0], pz - bridge.points[0][1])
+  }
+  return nearest
+}
+
+function inFrontOrNearby(
+  dx: number,
+  dz: number,
+  lookX: number,
+  lookZ: number,
+): boolean {
+  const distSq = dx * dx + dz * dz
+  if (distSq <= WALK_AROUND * WALK_AROUND) return true
+  const dist = Math.sqrt(distSq)
+  return (dx / dist) * lookX + (dz / dist) * lookZ >= WALK_BEHIND_DOT
+}
+
+export function walkLodCell(
+  x: number,
+  z: number,
+  y: number,
+  lookX: number,
+  lookZ: number,
+) {
+  const angle = Math.atan2(lookX, lookZ)
+  const bucket = Math.round(angle / (Math.PI / 10))
+  const heightBand = Math.round(Math.max(0, y - CONFIG.eyeHeight) / 6)
+  return `${Math.round(x / 4)}:${Math.round(z / 4)}:${heightBand}:${bucket}`
+}
+
+function sameSet(left: Set<string>, right: Set<string>) {
+  if (left.size !== right.size) return false
+  for (const id of left) {
+    if (!right.has(id)) return false
+  }
+  return true
+}
+
+export function sameWalkLod(left: WalkLod | null, right: WalkLod) {
+  if (!left) return false
+  return (
+    sameSet(left.files, right.files) &&
+    sameSet(left.labels, right.labels) &&
+    sameSet(left.folders, right.folders) &&
+    sameSet(left.folderLabels, right.folderLabels) &&
+    sameSet(left.bridges, right.bridges)
+  )
+}
+
+export function heightBoost(y: number) {
+  return Math.max(0, y - CONFIG.eyeHeight)
+}
+
+export function computeWalkLod({
+  x,
+  z,
+  y = CONFIG.eyeHeight,
+  lookX,
+  lookZ,
+  files,
+  folders,
+  bridges,
+  keepFileIds,
+  keepFolderPaths,
+  prev,
+}: {
+  x: number
+  z: number
+  y?: number
+  lookX: number
+  lookZ: number
+  files: Record<string, PlacedFile>
+  folders: Record<string, PlacedFolder>
+  bridges: PlacedBridge[]
+  keepFileIds: Iterable<string>
+  keepFolderPaths: Iterable<string>
+  prev: WalkLod | null
+}): WalkLod {
+  const boost = heightBoost(y)
+  const meshRadius = WALK_MESH_RADIUS + boost * 2.4
+  const meshKeep = WALK_MESH_KEEP + boost * 2.4
+  const labelRadius = WALK_LABEL_RADIUS + boost * 0.6
+  const labelKeep = WALK_LABEL_KEEP + boost * 0.6
+  const folderPad = WALK_FOLDER_PAD + boost * 3
+  const lookLen = Math.hypot(lookX, lookZ) || 1
+  const nx = lookX / lookLen
+  const nz = lookZ / lookLen
+
+  const nextFiles = new Set<string>()
+  const nextLabels = new Set<string>()
+  for (const id of keepFileIds) nextFiles.add(id)
+
+  for (const [id, placed] of Object.entries(files)) {
+    const dx = placed.position[0] - x
+    const dz = placed.position[2] - z
+    const dist = Math.hypot(dx, dz)
+    const kept = Boolean(prev?.files.has(id))
+    const labeled = Boolean(prev?.labels.has(id))
+    const meshLimit = kept ? meshKeep : meshRadius
+    const labelLimit = labeled ? labelKeep : labelRadius
+    if (dist > meshLimit) continue
+    if (!inFrontOrNearby(dx, dz, nx, nz) && dist > WALK_AROUND) continue
+    nextFiles.add(id)
+    if (dist <= labelLimit) nextLabels.add(id)
+  }
+
+  const nextFolders = new Set<string>()
+  const nextFolderLabels = new Set<string>()
+  for (const path of keepFolderPaths) nextFolders.add(path)
+
+  for (const folder of Object.values(folders)) {
+    const dist = folderDistance(x, z, folder)
+    const kept = Boolean(prev?.folders.has(folder.path))
+    const limit = kept ? folderPad + 18 : folderPad
+    if (dist > limit && !nextFolders.has(folder.path)) continue
+    nextFolders.add(folder.path)
+    if (dist <= WALK_FOLDER_LABEL) nextFolderLabels.add(folder.path)
+  }
+
+  const nextBridges = new Set<string>()
+  for (const bridge of bridges) {
+    const dist = bridgeDistance(x, z, bridge)
+    const kept = Boolean(prev?.bridges.has(bridge.id))
+    const limit = kept ? folderPad + 18 : folderPad
+    if (dist <= limit) nextBridges.add(bridge.id)
+  }
+
+  return {
+    files: nextFiles,
+    labels: nextLabels,
+    folders: nextFolders,
+    folderLabels: nextFolderLabels,
+    bridges: nextBridges,
+  }
+}

package/apps/explorer/src/types.ts

@@ -255,6 +255,7 @@ export type WorkflowAction =
 
 export type AgentIntentBundle = {
   focusedSessionId: string | null
+  nextAttachSessionId: string | null
   intents: AgentIntent[]
 }
 

package/apps/explorer/src/ui/HUD.tsx

@@ -214,9 +214,23 @@ function AddIntentRow({
   )
 }
 
+function AttachStateBadge({ attached }: { attached: boolean }) {
+  return (
+    <span
+      className="hud-attach-badge"
+      data-attached={attached}
+      aria-label={attached ? 'LLM attached' : 'Waiting for LLM'}
+    >
+      <span className="hud-attach-dot" aria-hidden="true" />
+      {attached ? 'Attached' : 'Waiting'}
+    </span>
+  )
+}
+
 function PanelChrome({
   title,
   subtitle,
+  badge,
   minimized = false,
   onMinimize,
   onClose,
@@ -225,6 +239,7 @@ function PanelChrome({
 }: {
   title: ReactNode
   subtitle?: ReactNode
+  badge?: ReactNode
   minimized?: boolean
   onMinimize?: () => void
   onClose?: () => void
@@ -234,7 +249,10 @@ function PanelChrome({
   return (
     <div className="hud-panel-chrome">
       <div className="hud-panel-chrome-heading">
-        <div className="hud-panel-chrome-title">{title}</div>
+        <div className="hud-panel-chrome-title-row">
+          <div className="hud-panel-chrome-title">{title}</div>
+          {badge}
+        </div>
         {subtitle ? (
           <div className="hud-panel-chrome-subtitle">{subtitle}</div>
         ) : null}
@@ -305,13 +323,13 @@ function HandshakeSetup({
   onInstructionChange,
   blueprintDefined,
   awaitingAttach,
-  attachBlockedBy,
+  nextAttachLabel,
 }: {
   instruction: string
   onInstructionChange: (value: string) => void
   blueprintDefined: boolean
   awaitingAttach: boolean
-  attachBlockedBy: string | null
+  nextAttachLabel: string | null
 }) {
   return (
     <div className="hud-setup">
@@ -339,10 +357,10 @@ function HandshakeSetup({
       </section>
       <section className="hud-setup-section">
         <h2 className="hud-setup-heading">Start</h2>
-        {attachBlockedBy ? (
+        {awaitingAttach && nextAttachLabel ? (
           <p>
-            An LLM is already attached to {attachBlockedBy}. Stop that session
-            before running <kbd>/inbase</kbd>.
+            <kbd>/inbase</kbd> attaches {nextAttachLabel} first. This session
+            stays in the queue.
           </p>
         ) : awaitingAttach ? (
           <p>
@@ -350,7 +368,7 @@ function HandshakeSetup({
           </p>
         ) : (
           <p>
-            Starting from <kbd>/inbase</kbd>…
+            This window is attached. Starting from <kbd>/inbase</kbd>…
           </p>
         )}
       </section>
@@ -462,7 +480,7 @@ type SessionPanelProps = {
   intent: AgentIntent
   focused: boolean
   naming: boolean
-  attachedSession?: AgentIntent | null
+  nextAttachSession?: AgentIntent | null
   onFocus: () => void
   onWorkflowAction: (
     sessionId: string,
@@ -476,7 +494,7 @@ function SessionPanel({
   intent,
   focused,
   naming,
-  attachedSession = null,
+  nextAttachSession = null,
   onFocus,
   onWorkflowAction,
   onNavigateDiff,
@@ -563,11 +581,11 @@ function SessionPanel({
   const llmConnected = intent.awaitingAttach === false
   const showConnectedProgress =
     llmConnected && (askingBlueprint || sendingBlueprint || preparing)
-  const attachBlockedBy =
+  const queuedBehind =
     intent.awaitingAttach &&
-    attachedSession &&
-    attachedSession.sessionId !== sessionId
-      ? sessionLabel(attachedSession) || 'another session'
+    nextAttachSession &&
+    nextAttachSession.sessionId !== sessionId
+      ? sessionLabel(nextAttachSession) || 'a newer session'
       : null
 
   const act = (
@@ -584,6 +602,7 @@ function SessionPanel({
       }
       data-minimized={minimized}
       data-focused={focused}
+      data-attached={llmConnected}
       onPointerDown={onFocus}
     >
       <PanelChrome
@@ -598,6 +617,7 @@ function SessionPanel({
               : reviewTitle(intent.status)
             : undefined
         }
+        badge={<AttachStateBadge attached={llmConnected} />}
         minimized={minimized}
         onMinimize={() => setMinimized((current) => !current)}
         onClose={() => act('stop')}
@@ -637,20 +657,18 @@ function SessionPanel({
               onInstructionChange={updateInitialInstruction}
               blueprintDefined={blueprintIsDefined(intent)}
               awaitingAttach={Boolean(intent.awaitingAttach)}
-              attachBlockedBy={attachBlockedBy || null}
+              nextAttachLabel={queuedBehind}
             />
           ) : intent.awaitingAttach ? (
-            attachedSession &&
-            attachedSession.sessionId !== sessionId ? (
+            queuedBehind ? (
               <p className="hud-mode-hint">
-                An LLM is already attached to{' '}
-                {sessionLabel(attachedSession) || 'another session'}. Stop that
-                session before running <kbd>/inbase</kbd>.
+                <kbd>/inbase</kbd> attaches {queuedBehind} first. This session
+                stays in the queue.
               </p>
             ) : (
               <p className="hud-mode-hint">
                 No LLM is attached. Open a Cursor chat and run{' '}
-                <kbd>/inbase</kbd>. It connects to this focused session.
+                <kbd>/inbase</kbd>. It connects to the next waiting session.
               </p>
             )
           ) : null}
@@ -1207,7 +1225,7 @@ function explorerInstructions({
         {
           id: 'setup-session',
           keys: ['Setup LLM session'],
-          label: 'Open a session; /inbase connects the focused one',
+          label: 'Open a session; /inbase attaches the newest waiting one',
         },
         { id: 'toggle-map', keys: ['M'], label: 'Toggle map' },
         {
@@ -1294,7 +1312,7 @@ function explorerInstructions({
         {
           id: 'setup-session',
           keys: ['Setup LLM session'],
-          label: 'Open a session; /inbase connects the focused one',
+          label: 'Open a session; /inbase attaches the newest waiting one',
         },
         { id: 'map-walk', keys: ['M'], label: 'Back to walk' },
         ...stop,
@@ -1318,6 +1336,7 @@ type HUDProps = {
   intent: AgentIntent
   intents?: AgentIntent[]
   focusedSessionId?: string | null
+  nextAttachSessionId?: string | null
   onFocusSession?: (sessionId: string) => void
   onSetupSession?: () => Promise<unknown>
   onWorkflowAction: (
@@ -1383,6 +1402,7 @@ export function HUD({
   intent,
   intents,
   focusedSessionId = null,
+  nextAttachSessionId = null,
   onFocusSession,
   onSetupSession,
   onWorkflowAction,
@@ -1444,8 +1464,10 @@ export function HUD({
     (item) => item.sessionId && isReviewingIntent(item.status),
   )
   const canStop = canStopSession(intent)
-  const attachedSession =
-    sessions.find((session) => session.awaitingAttach === false) ?? null
+  const nextAttachSession =
+    sessions.find((session) => session.sessionId === nextAttachSessionId) ??
+    [...sessions].reverse().find((session) => session.awaitingAttach) ??
+    null
   const [walkIntro, setWalkIntro] = useState(false)
   const walkIntroSeen = useRef(false)
   const [instructionsOpen, setInstructionsOpen] = useState(false)
@@ -1783,6 +1805,8 @@ export function HUD({
               {sessions.map((session) => {
                 const active =
                   session.sessionId === (focusedSessionId ?? intent.sessionId)
+                const attached = session.awaitingAttach === false
+                const label = sessionTabLabel(session, sessions)
                 return (
                   <button
                     className="hud-button hud-session-tab"
@@ -1790,13 +1814,15 @@ export function HUD({
                     role="tab"
                     aria-selected={active}
                     data-active={active}
+                    data-attached={attached}
                     key={session.sessionId}
-                    title={sessionTabLabel(session, sessions)}
+                    title={attached ? `${label} · Attached` : `${label} · Waiting`}
                     onClick={() => {
                       if (session.sessionId) onFocusSession?.(session.sessionId)
                     }}
                   >
-                    {sessionTabLabel(session, sessions)}
+                    <span className="hud-attach-dot" aria-hidden="true" />
+                    <span className="hud-session-tab-label">{label}</span>
                   </button>
                 )
               })}
@@ -1807,7 +1833,7 @@ export function HUD({
               intent={intent}
               focused
               naming={naming}
-              attachedSession={attachedSession}
+              nextAttachSession={nextAttachSession}
               onFocus={() => {
                 if (intent.sessionId) onFocusSession?.(intent.sessionId)
               }}

package/apps/explorer/vite.config.ts

@@ -17,6 +17,7 @@ import {
   inspectTargetFile,
   invokeStep,
   listSessionIntents,
+  nextAttachSessionId,
   readActiveSession,
   requestReplan,
   sendBlueprint,
@@ -142,6 +143,7 @@ function jsonFilePlugin(): Plugin {
           }
           sendJson(res, 200, {
             focusedSessionId: readActiveSession(dataDir),
+            nextAttachSessionId: nextAttachSessionId(dataDir),
             intents: listSessionIntents(dataDir, knownFileIds()),
           })
           return

package/bin/session.mjs

@@ -179,7 +179,7 @@ export async function attachSession(args) {
   console.log(`VISUAL_CODER_SESSION ${manifest.sessionId}`)
   printAck('attached', manifest.name || manifest.sessionId)
   console.log(
-    `VISUAL_CODER_ATTACHED Attached to the focused visualizer session ${manifest.name || manifest.sessionId} (${manifest.phase}). Use --session ${manifest.sessionId} for every later command. Run inbase wait-for-blueprint --session ${manifest.sessionId} to read the optional blueprint and instruction; it does not wait.`,
+    `VISUAL_CODER_ATTACHED Attached to the next waiting visualizer session ${manifest.name || manifest.sessionId} (${manifest.phase}). Use --session ${manifest.sessionId} for every later command. Run inbase wait-for-blueprint --session ${manifest.sessionId} to read the optional blueprint and instruction; it does not wait.`,
   )
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jkwd/inbase",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "A first-person 3D map of a codebase, with a visual coding workflow for Cursor.",
   "license": "MIT",
   "author": "Joris Kuijper",

package/skill/commands/inbase.md

@@ -1,12 +1,12 @@
 ---
-description: Attach this chat to the focused Inbase visualizer session
+description: Attach this chat to the next waiting Inbase visualizer session
 ---
 
 The user invoked `/inbase`. This is how a chat joins the visualizer session that **Setup LLM session** already created.
 
 Do **not** ask for a session id. Do **not** run `inbase start-session`. Do **not** print the "direct chat interaction not allowed" message.
 
-1. Attach to the focused visualizer session:
+1. Attach to the next waiting visualizer session (newest first; skip sessions that already have an LLM):
 
 ```bash
 npx inbase attach

package/skill/inbase/SKILL.md

@@ -57,7 +57,8 @@ If this chat is not yet attached, run:
 npx inbase attach
 ```
 
-That attaches this chat to the session currently focused in the map. No id is
+That attaches this chat to the next waiting visualizer session (newest first).
+Already-attached sessions are skipped. Window focus does not matter. No id is
 passed in; read `VISUAL_CODER_SESSION` from the output and use that
 `--session` value for every later command. Then continue from
 `wait-for-blueprint` below. Do **not** run `start-session`. Do **not** wait