@jkwd/inbase 0.1.10 → 0.1.12

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

@@ -0,0 +1,89 @@
+import { useEffect } from 'react'
+import { createPortal } from 'react-dom'
+
+export type MapContextMenuState = {
+  x: number
+  y: number
+  folder: string
+}
+
+type MapContextMenuProps = {
+  menu: MapContextMenuState | null
+  onAddFile: (folder: string) => void
+  onAddFolder: (folder: string) => void
+  onClose: () => void
+}
+
+export function MapContextMenu({
+  menu,
+  onAddFile,
+  onAddFolder,
+  onClose,
+}: MapContextMenuProps) {
+  useEffect(() => {
+    if (!menu) return
+    const onKey = (event: KeyboardEvent) => {
+      if (event.code !== 'Escape') return
+      event.preventDefault()
+      onClose()
+    }
+    const onPointerDown = (event: PointerEvent) => {
+      const target = event.target
+      if (target instanceof Element && target.closest('.map-context-menu')) {
+        return
+      }
+      onClose()
+    }
+    window.addEventListener('keydown', onKey)
+    window.addEventListener('pointerdown', onPointerDown, true)
+    return () => {
+      window.removeEventListener('keydown', onKey)
+      window.removeEventListener('pointerdown', onPointerDown, true)
+    }
+  }, [menu, onClose])
+
+  if (!menu) return null
+
+  const pad = 8
+  const width = 176
+  const height = 84
+  const left = Math.min(
+    Math.max(pad, menu.x),
+    window.innerWidth - width - pad,
+  )
+  const top = Math.min(
+    Math.max(pad, menu.y),
+    window.innerHeight - height - pad,
+  )
+
+  return createPortal(
+    <div
+      className="map-context-menu"
+      role="menu"
+      style={{ left, top }}
+      onContextMenu={(event) => event.preventDefault()}
+    >
+      <button
+        type="button"
+        role="menuitem"
+        onClick={() => {
+          onAddFile(menu.folder)
+          onClose()
+        }}
+      >
+        Add file
+      </button>
+      <button
+        type="button"
+        role="menuitem"
+        onClick={() => {
+          onAddFolder(menu.folder)
+          onClose()
+        }}
+      >
+        Add folder
+      </button>
+    </div>,
+    document.body,
+  )
+}

package/apps/explorer/src/userContext.ts

@@ -38,6 +38,16 @@ export function persistFollowLook(followLook: boolean) {
   })
 }
 
+export function persistShowBranchChanges(showBranchChanges: boolean) {
+  fetch('/api/user-context', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: `${JSON.stringify({ showBranchChanges })}\n`,
+  }).catch(() => {
+    lastWritten = ''
+  })
+}
+
 export function persistUserContext(context: UserContext) {
   pending = context
   if (timer !== null) return
@@ -51,6 +61,7 @@ function flushUserContext() {
   if (!context) return
   const {
     followLook: _followLook,
+    showBranchChanges: _showBranchChanges,
     userCreatedBlocks: _userCreatedBlocks,
     userCreatedIslands: _userCreatedIslands,
     ...gaze

package/apps/explorer/src/userCreated.ts

@@ -5,6 +5,7 @@ import type {
   FileNode,
   PatchImportAddition,
   PatchSymbolAddition,
+  PlacedFolder,
   UserCreatedBlock,
   UserCreatedIsland,
   WorldLayout,
@@ -193,6 +194,54 @@ export function withUserCreatedGraph(
   }
 }
 
+function placedFolderParent(
+  folder: PlacedFolder,
+  islands: UserCreatedIsland[],
+) {
+  const created = islands.find((item) => islandKey(item) === folder.path)
+  if (created) return created.parent
+  return folderParent(folder.path)
+}
+
+function expandParentsToChildren(
+  folders: Record<string, PlacedFolder>,
+  islands: UserCreatedIsland[],
+) {
+  const parentPaths = new Set<string>()
+  for (const island of islands) {
+    let current: string | null = island.parent
+    while (current) {
+      parentPaths.add(current)
+      current = folderParent(current)
+    }
+  }
+  const ordered = [...parentPaths].sort(
+    (left, right) =>
+      right.split('/').filter(Boolean).length -
+      left.split('/').filter(Boolean).length,
+  )
+  for (const parentPath of ordered) {
+    const parent = folders[parentPath]
+    if (!parent) continue
+    const children = Object.values(folders).filter(
+      (folder) =>
+        folder.path !== parentPath &&
+        placedFolderParent(folder, islands) === parentPath,
+    )
+    if (children.length === 0) continue
+    let extent = parent.width / 2
+    for (const child of children) {
+      extent = Math.max(
+        extent,
+        Math.abs(child.x - child.width / 2 - parent.x),
+        Math.abs(child.x + child.width / 2 - parent.x),
+      )
+    }
+    const width = extent * 2
+    if (width > parent.width) folders[parentPath] = { ...parent, width }
+  }
+}
+
 function overlayIslands(
   layout: WorldLayout,
   islands: UserCreatedIsland[],
@@ -245,6 +294,7 @@ function overlayIslands(
     })
   }
 
+  expandParentsToChildren(folders, islands)
   return { ...layout, folders, bridges }
 }
 

package/apps/explorer/vite.config.ts

@@ -6,11 +6,13 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { emptyIntent } from './scripts/patch-lib.mjs'
+import { readBranchChanges } from './scripts/branch-changes.mjs'
+import { writeRunningInstance } from '../../bin/project.mjs'
 import { dataDir, targetRoot } from './scripts/target-config.mjs'
 import { editorFileUri, openInEditor } from './scripts/open-editor.mjs'
 import {
   answerBlueprint,
-  recoverOpenDiffSessions,
+  clearDiffSessions,
   continueDiff,
   inspectTargetFile,
   invokeStep,
@@ -19,7 +21,9 @@ import {
   requestReplan,
   sendBlueprint,
   sessionIntent,
+  setInitialInstruction,
   setStepByStep,
+  setupSession,
   focusSession,
   stopSession,
   updateBlueprint,
@@ -85,8 +89,14 @@ function jsonFilePlugin(): Plugin {
   return {
     name: 'visual-coder-json-files',
     configureServer(server) {
-      recoverOpenDiffSessions(dataDir, targetRoot)
-      rescanTarget('after recovering diff sessions')
+      writeRunningInstance({
+        dataDir,
+        targetRoot,
+        port: server.config.server.port ?? 5173,
+      })
+      // Always boot with no LLM session. Leftover diffs and pointers are not restored.
+      clearDiffSessions(dataDir, targetRoot)
+      rescanTarget('after discarding leftover LLM sessions')
       server.middlewares.use('/api/user-context', (req, res, next) => {
         if (req.method === 'GET') {
           sendJson(res, 200, readUserContext())
@@ -145,6 +155,14 @@ function jsonFilePlugin(): Plugin {
         next()
       })
 
+      server.middlewares.use('/api/branch-changes', (req, res, next) => {
+        if (req.method === 'GET') {
+          sendJson(res, 200, readBranchChanges(targetRoot, knownFileIds()))
+          return
+        }
+        next()
+      })
+
       server.middlewares.use('/api/inspect-file', (req, res, next) => {
         if (req.method === 'POST') {
           void inspectFile(req, res)
@@ -191,6 +209,7 @@ async function decideIntent(req: IncomingMessage, res: ServerResponse) {
       sessionId?: string
       diffId?: string
       instruction?: string
+      name?: string
       step?: number
       stepByStep?: boolean
       userCreatedBlocks?: unknown[]
@@ -210,12 +229,14 @@ async function decideIntent(req: IncomingMessage, res: ServerResponse) {
       action !== 'blueprint_send' &&
       action !== 'blueprint_update' &&
       action !== 'focus' &&
-      action !== 'set_step_by_step'
+      action !== 'set_step_by_step' &&
+      action !== 'set_initial_instruction' &&
+      action !== 'setup_session'
     ) {
       sendJson(res, 400, { error: 'invalid workflow action' })
       return
     }
-    if (!body.sessionId) {
+    if (action !== 'setup_session' && !body.sessionId) {
       sendJson(res, 400, { error: 'sessionId is required' })
       return
     }
@@ -227,13 +248,20 @@ async function decideIntent(req: IncomingMessage, res: ServerResponse) {
       return
     }
 
+    if (
+      body.name !== undefined &&
+      (typeof body.name !== 'string' || body.name.length > 200)
+    ) {
+      sendJson(res, 400, { error: 'name must be a string up to 200 characters' })
+      return
+    }
+
     if (action === 'invoke') {
       if (!Number.isInteger(body.step)) {
         sendJson(res, 400, { error: 'step is required for invoke' })
         return
       }
       invokeStep(dataDir, body.sessionId, body.step as number, targetRoot)
-      rescanTarget('after invoking step')
     } else if (action === 'continue') {
       if (!body.diffId) {
         sendJson(res, 400, { error: 'diffId is required for continue' })
@@ -274,6 +302,16 @@ async function decideIntent(req: IncomingMessage, res: ServerResponse) {
         addedVariables: body.addedVariables,
         addedImports: body.addedImports,
       })
+    } else if (action === 'setup_session') {
+      const manifest = setupSession(dataDir, {
+        sessionId: body.sessionId,
+        name: body.name,
+      })
+      const next = sessionIntent(dataDir, manifest.sessionId, knownFileIds())
+      sendJson(res, 200, next ?? { ...emptyIntent })
+      return
+    } else if (action === 'set_initial_instruction') {
+      setInitialInstruction(dataDir, body.sessionId, body.instruction ?? '')
     } else if (action === 'focus') {
       focusSession(dataDir, body.sessionId)
     } else if (action === 'set_step_by_step') {
@@ -330,9 +368,10 @@ function readUserContext() {
     return {
       ...parsed,
       followLook: Boolean(parsed.followLook),
+      showBranchChanges: Boolean(parsed.showBranchChanges),
     }
   } catch {
-    return { followLook: false }
+    return { followLook: false, showBranchChanges: false }
   }
 }
 
@@ -347,6 +386,10 @@ async function writeUserContext(req: IncomingMessage, res: ServerResponse) {
         typeof incoming.followLook === 'boolean'
           ? incoming.followLook
           : Boolean(existing.followLook),
+      showBranchChanges:
+        typeof incoming.showBranchChanges === 'boolean'
+          ? incoming.showBranchChanges
+          : Boolean(existing.showBranchChanges),
     }
     delete next.userCreatedBlocks
     delete next.userCreatedIslands
@@ -360,10 +403,21 @@ async function writeUserContext(req: IncomingMessage, res: ServerResponse) {
   }
 }
 
+function isDataDirPath(filePath: string) {
+  const file = path.resolve(filePath)
+  const root = path.resolve(dataDir)
+  return file === root || file.startsWith(root + path.sep)
+}
+
 export default defineConfig({
   plugins: [react(), jsonFilePlugin()],
   server: {
     port: 5173,
+    watch: {
+      // Session snapshots copy target source into the data dir. If Vite
+      // watches those writes, Create proposal full-reloads the visualizer.
+      ignored: ['**/src/data/**', isDataDirPath],
+    },
     fs: {
       allow: [here, dataDir],
     },

package/bin/inbase.mjs

@@ -10,12 +10,14 @@ import {
   ensureGitignoreEntry,
   explorerRoot,
   skillTemplateDir,
+  commandTemplateDir,
   takeFlagValue,
 } from './project.mjs'
 import {
   proposePatch,
   reportPlan,
   startSession,
+  attachSession,
   waitForApproval,
   waitForBlueprint,
 } from './session.mjs'
@@ -28,11 +30,12 @@ Usage:
   inbase help              Show this help
 
 Agent commands (used by the Cursor skill):
-  inbase start-session --session <id> [--feature "name"]
+  inbase start-session --session <id> --name "short name"
+  inbase attach [--session <id>]
   inbase wait-for-blueprint --session <id>
   inbase report-plan --session <id> --feature "name" --steps "one" [--steps "two"]
   inbase wait-for-approval --session <id>
-  inbase propose-patch --session <id> <file.patch|->
+  inbase propose-patch --session <id> [file.patch|-]
   inbase propose-patch --session <id> --clear
 
 Options for run:
@@ -50,6 +53,10 @@ export function initProject(projectRoot = process.cwd()) {
   }
   const skillDir = path.join(projectRoot, '.cursor/skills/inbase')
   copyDir(skillTemplateDir, skillDir)
+  const commandDir = path.join(projectRoot, '.cursor/commands')
+  if (fs.existsSync(commandTemplateDir)) {
+    copyDir(commandTemplateDir, commandDir)
+  }
   const { dataDir } = applyHostEnv({
     cwd: projectRoot,
     target: projectRoot,
@@ -57,7 +64,7 @@ export function initProject(projectRoot = process.cwd()) {
   })
   ensureDataDir(dataDir)
   const gitignoreAdded = ensureGitignoreEntry(projectRoot)
-  return { skillDir, dataDir, gitignoreAdded }
+  return { skillDir, commandDir, dataDir, gitignoreAdded }
 }
 
 function explorerHref(relative) {
@@ -122,6 +129,9 @@ export async function main(argv = process.argv.slice(2)) {
   if (command === 'init') {
     const result = initProject()
     console.log(`Installed Cursor skill at ${result.skillDir}`)
+    if (fs.existsSync(path.join(result.commandDir, 'inbase.md'))) {
+      console.log(`Installed /inbase command at ${result.commandDir}`)
+    }
     if (result.gitignoreAdded) console.log('Added .inbase/ to .gitignore')
     console.log('Next: run `inbase run`, then ask Cursor to change source files.')
     return
@@ -132,13 +142,22 @@ export async function main(argv = process.argv.slice(2)) {
     return
   }
 
-  applyHostEnv()
+  const host = applyHostEnv()
   ensureDataDir(process.env.INBASE_DATA_DIR)
+  if (host.instance) {
+    console.log(
+      `INBASE_ATTACHED Using the running visualizer (${host.instance.dataDir}). Run wait-for-blueprint to read the optional blueprint; it does not wait.`,
+    )
+  }
 
   if (command === 'start-session') {
     await startSession(args)
     return
   }
+  if (command === 'attach') {
+    await attachSession(args)
+    return
+  }
   if (command === 'wait-for-blueprint') {
     await waitForBlueprint(args)
     return

package/bin/project.mjs

@@ -6,6 +6,7 @@ const here = path.dirname(fileURLToPath(import.meta.url))
 export const packageRoot = path.resolve(here, '..')
 export const explorerRoot = path.join(packageRoot, 'apps/explorer')
 export const skillTemplateDir = path.join(packageRoot, 'skill/inbase')
+export const commandTemplateDir = path.join(packageRoot, 'skill/commands')
 
 export function resolveOptionalPath(value, fallback) {
   const raw = value?.trim()
@@ -13,19 +14,76 @@ export function resolveOptionalPath(value, fallback) {
   return path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(process.cwd(), raw)
 }
 
+export const INSTANCE_FILE = 'instance.json'
+
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid)) return true
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function instanceFile(dataDir) {
+  return path.join(dataDir, INSTANCE_FILE)
+}
+
+export function writeRunningInstance({ dataDir, targetRoot, port = null }) {
+  fs.mkdirSync(dataDir, { recursive: true })
+  const instance = {
+    dataDir: path.resolve(dataDir),
+    targetRoot: path.resolve(targetRoot),
+    port: port ?? null,
+    pid: process.pid,
+    updatedAt: new Date().toISOString(),
+  }
+  fs.writeFileSync(instanceFile(dataDir), `${JSON.stringify(instance, null, 2)}\n`)
+  return instance
+}
+
+export function readInstanceFile(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (!parsed?.dataDir || !parsed?.targetRoot) return null
+    if (!isPidAlive(parsed.pid)) return null
+    return parsed
+  } catch {
+    return null
+  }
+}
+
+export function readRunningInstance(cwd = process.cwd()) {
+  const files = [
+    path.join(cwd, '.inbase', INSTANCE_FILE),
+    path.join(explorerRoot, 'src/data', INSTANCE_FILE),
+  ]
+  const seen = new Set()
+  for (const file of files) {
+    const resolved = path.resolve(file)
+    if (seen.has(resolved) || !fs.existsSync(resolved)) continue
+    seen.add(resolved)
+    const instance = readInstanceFile(resolved)
+    if (instance) return instance
+  }
+  return null
+}
+
 export function applyHostEnv({
   cwd = process.cwd(),
   target = process.env.VISUAL_CODER_TARGET,
   dataDir = process.env.INBASE_DATA_DIR,
 } = {}) {
-  const targetRoot = resolveOptionalPath(target, cwd)
+  const running = !target && !dataDir ? readRunningInstance(cwd) : null
+  const targetRoot = resolveOptionalPath(target, running?.targetRoot ?? cwd)
   const resolvedDataDir = resolveOptionalPath(
     dataDir,
-    path.join(targetRoot, '.inbase'),
+    running?.dataDir ?? path.join(targetRoot, '.inbase'),
   )
   process.env.VISUAL_CODER_TARGET = targetRoot
   process.env.INBASE_DATA_DIR = resolvedDataDir
-  return { cwd, targetRoot, dataDir: resolvedDataDir }
+  return { cwd, targetRoot, dataDir: resolvedDataDir, instance: running }
 }
 
 export function ensureDataDir(dataDir) {
@@ -34,7 +92,7 @@ export function ensureDataDir(dataDir) {
   if (!fs.existsSync(userContextFile)) {
     fs.writeFileSync(
       userContextFile,
-      `${JSON.stringify({ followLook: false }, null, 2)}\n`,
+      `${JSON.stringify({ followLook: false, showBranchChanges: false }, null, 2)}\n`,
     )
   }
   return dataDir