@jkwd/inbase 0.1.1 → 0.1.4

package/apps/explorer/scripts/open-editor.d.ts

@@ -0,0 +1,6 @@
+export function editorFileUri(filePath: string): string
+export function defaultCursorUserDataDir(): string
+export function discoverCursorUserDataDirs(): string[]
+export function openFoldersFromStorage(storage: unknown): string[]
+export function cursorUserDataDirForFile(filePath: string): string | null
+export function openInEditor(filePath: string): boolean

package/apps/explorer/scripts/open-editor.mjs

@@ -0,0 +1,219 @@
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+export function editorFileUri(filePath) {
+  return `vscode://file${encodeURI(filePath)}`
+}
+
+function which(command) {
+  const result = spawnSync('which', [command], { encoding: 'utf8' })
+  if (result.error || result.status !== 0) return null
+  return result.stdout.trim().split('\n')[0] || null
+}
+
+export function defaultCursorUserDataDir() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library/Application Support/Cursor')
+  }
+  if (process.platform === 'win32') {
+    return path.join(os.homedir(), 'AppData/Roaming/Cursor')
+  }
+  return path.join(os.homedir(), '.config/Cursor')
+}
+
+function expandUser(value) {
+  if (!value) return null
+  const trimmed = String(value).trim().replace(/^['"]|['"]$/g, '')
+  if (!trimmed) return null
+  if (trimmed.startsWith('~')) {
+    return path.resolve(os.homedir() + trimmed.slice(1))
+  }
+  return path.resolve(trimmed)
+}
+
+function isCursorUserDataDir(dir) {
+  try {
+    if (fs.existsSync(path.join(dir, 'User/globalStorage/storage.json'))) return true
+    return fs.readdirSync(dir).some((name) => name.endsWith('-main.sock'))
+  } catch {
+    return false
+  }
+}
+
+function userDataDirFromHook(hook = process.env.VSCODE_IPC_HOOK) {
+  if (!hook || !hook.endsWith('.sock')) return null
+  const dir = path.dirname(hook)
+  return isCursorUserDataDir(dir) ? dir : null
+}
+
+function userDataDirsFromProcessList() {
+  const result = spawnSync('ps', ['-ax', '-o', 'command='], { encoding: 'utf8' })
+  if (result.error || result.status !== 0) return []
+  const dirs = []
+  for (const line of result.stdout.split('\n')) {
+    const match = line.match(/--user-data-dir(?:=|\s+)(\S+)/)
+    if (!match) continue
+    const dir = expandUser(match[1])
+    if (dir && isCursorUserDataDir(dir)) dirs.push(dir)
+  }
+  return dirs
+}
+
+function profileDirsInHome() {
+  let names = []
+  try {
+    names = fs.readdirSync(os.homedir())
+  } catch {
+    return []
+  }
+  return names
+    .filter((name) => name.startsWith('cursor-profile'))
+    .map((name) => path.join(os.homedir(), name))
+    .filter(isCursorUserDataDir)
+}
+
+export function discoverCursorUserDataDirs() {
+  const dirs = new Set()
+  const explicit = expandUser(
+    process.env.INBASE_CURSOR_USER_DATA_DIR || process.env.CURSOR_USER_DATA_DIR,
+  )
+  if (explicit && isCursorUserDataDir(explicit)) dirs.add(explicit)
+  const hookDir = userDataDirFromHook()
+  if (hookDir) dirs.add(hookDir)
+  const def = defaultCursorUserDataDir()
+  if (isCursorUserDataDir(def)) dirs.add(def)
+  for (const dir of profileDirsInHome()) dirs.add(dir)
+  for (const dir of userDataDirsFromProcessList()) dirs.add(dir)
+  return [...dirs]
+}
+
+function folderPathFromUri(value) {
+  if (typeof value !== 'string' || !value) return null
+  try {
+    return value.startsWith('file:') ? fileURLToPath(value) : path.resolve(value)
+  } catch {
+    return null
+  }
+}
+
+function fileIsInside(folder, filePath) {
+  const root = path.resolve(folder)
+  const file = path.resolve(filePath)
+  return file === root || file.startsWith(`${root}${path.sep}`)
+}
+
+export function openFoldersFromStorage(storage) {
+  const state = storage?.windowsState
+  if (!state || typeof state !== 'object') return []
+  const windows = [
+    state.lastActiveWindow,
+    ...(Array.isArray(state.openedWindows) ? state.openedWindows : []),
+  ]
+  const folders = []
+  for (const window of windows) {
+    const folder = folderPathFromUri(window?.folder)
+    if (folder) folders.push(folder)
+  }
+  return folders
+}
+
+function readOpenFolders(userDataDir) {
+  const file = path.join(userDataDir, 'User/globalStorage/storage.json')
+  try {
+    return openFoldersFromStorage(JSON.parse(fs.readFileSync(file, 'utf8')))
+  } catch {
+    return []
+  }
+}
+
+function lastActiveFolder(userDataDir) {
+  const file = path.join(userDataDir, 'User/globalStorage/storage.json')
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
+    return folderPathFromUri(parsed?.windowsState?.lastActiveWindow?.folder)
+  } catch {
+    return null
+  }
+}
+
+export function cursorUserDataDirForFile(filePath) {
+  const explicit = expandUser(
+    process.env.INBASE_CURSOR_USER_DATA_DIR || process.env.CURSOR_USER_DATA_DIR,
+  )
+  if (explicit && isCursorUserDataDir(explicit)) return explicit
+
+  const hookDir = userDataDirFromHook()
+  let best = null
+  let bestScore = 0
+  for (const dir of discoverCursorUserDataDirs()) {
+    const folders = readOpenFolders(dir)
+    if (!folders.some((folder) => fileIsInside(folder, filePath))) continue
+    let score = 1
+    if (hookDir && path.resolve(hookDir) === path.resolve(dir)) score += 2
+    const last = lastActiveFolder(dir)
+    if (last && fileIsInside(last, filePath)) score += 2
+    if (score > bestScore) {
+      best = dir
+      bestScore = score
+    }
+  }
+  return best ?? hookDir
+}
+
+function cursorCliPaths() {
+  const home = os.homedir()
+  const fromEnv =
+    process.env.CURSOR_CLI && fs.existsSync(process.env.CURSOR_CLI)
+      ? process.env.CURSOR_CLI
+      : null
+  return [
+    fromEnv,
+    which('cursor'),
+    '/Applications/Cursor.app/Contents/Resources/app/bin/cursor',
+    path.join(home, '.local/bin/cursor'),
+    '/usr/local/bin/cursor',
+    '/opt/homebrew/bin/cursor',
+  ].filter((candidate, index, list) => {
+    if (!candidate || typeof candidate !== 'string') return false
+    return list.indexOf(candidate) === index
+  })
+}
+
+function editorEnv() {
+  const env = { ...process.env }
+  delete env.ELECTRON_RUN_AS_NODE
+  delete env.ELECTRON_NO_ASAR
+  delete env.CURSOR_AGENT
+  // A second Cursor instance uses its own sockets. Inherited hooks from
+  // another profile would send --goto to the wrong window.
+  delete env.VSCODE_IPC_HOOK
+  delete env.VSCODE_IPC_HOOK_CLI
+  return env
+}
+
+function runEditor(command, args) {
+  if (command.includes(path.sep) && !fs.existsSync(command)) return false
+  const result = spawnSync(command, args, {
+    stdio: 'ignore',
+    env: editorEnv(),
+  })
+  return !result.error && result.status === 0
+}
+
+export function openInEditor(filePath) {
+  const userDataDir = cursorUserDataDirForFile(filePath)
+  const goto = ['--goto', `${filePath}:1`]
+  if (userDataDir) {
+    goto.unshift('--user-data-dir', userDataDir)
+  }
+  for (const command of cursorCliPaths()) {
+    if (runEditor(command, goto)) return true
+  }
+
+  const code = which('code')
+  if (code && runEditor(code, goto)) return true
+  return false
+}

package/apps/explorer/scripts/session-store.d.ts

@@ -119,6 +119,36 @@ export function sessionIntent(
   knownFileIds?: string[],
   selectedDiffId?: string,
 ): Record<string, unknown> | null
+export function resolveTargetFile(
+  targetRoot: string,
+  fileId: string,
+): { id: string; absolute: string }
+export function captureBaseline(
+  dataDir: string,
+  sessionId: string,
+  targetRoot: string,
+  fileIds?: string[],
+): { files: Record<string, { existed: boolean }> }
+export function restoreBaseline(
+  dataDir: string,
+  sessionId: string,
+  targetRoot: string,
+): void
+export function materializeDiff(
+  dataDir: string,
+  targetRoot: string,
+  sessionId: string,
+  diffId?: string | null,
+): DiffManifest
+export function inspectTargetFile(
+  dataDir: string,
+  targetRoot: string,
+  input?: {
+    sessionId?: string | null
+    diffId?: string | null
+    fileId?: string | null
+  },
+): string | null
 export function appendDiff(
   dataDir: string,
   targetRoot: string,
@@ -142,7 +172,7 @@ export function requestReplan(
 export function stopSession(
   dataDir: string,
   sessionId: string,
-  diffId?: string,
+  targetRoot?: string | null,
 ): null
 export function decideDiff(
   dataDir: string,

package/apps/explorer/scripts/session-store.mjs

@@ -44,9 +44,28 @@ export function sessionPaths(dataDir, sessionId) {
     diffs: path.join(root, 'diffs'),
     manifest: path.join(root, 'manifest.json'),
     blueprint: path.join(root, 'blueprint.json'),
+    baseline: path.join(root, 'baseline.json'),
+    baselineFiles: path.join(root, 'baseline'),
   }
 }
 
+export function resolveTargetFile(targetRoot, fileId) {
+  if (typeof fileId !== 'string' || fileId.trim() === '') {
+    throw new Error('fileId is required')
+  }
+  const normalized = fileId.trim().replaceAll('\\', '/').replace(/^\/+/, '')
+  if (!normalized || normalized === '.' || normalized.includes('..')) {
+    throw new Error(`Invalid file id ${fileId}`)
+  }
+  const root = path.resolve(targetRoot)
+  const absolute = path.resolve(root, normalized)
+  const prefix = root.endsWith(path.sep) ? root : `${root}${path.sep}`
+  if (absolute !== root && !absolute.startsWith(prefix)) {
+    throw new Error(`Invalid file id ${fileId}`)
+  }
+  return { id: normalized, absolute }
+}
+
 export function readActiveSession(dataDir) {
   const value = readJson(path.join(dataDir, 'active-session.json'), null)
   return value?.sessionId ? assertSessionId(value.sessionId) : null
@@ -305,10 +324,105 @@ export function sessionIntent(dataDir, sessionId, knownFileIds = [], selectedDif
   }
 }
 
-function withVirtualTarget(targetRoot, patches, action) {
+function emptyBaseline() {
+  return { files: {} }
+}
+
+function readBaseline(dataDir, sessionId) {
+  const { baseline } = sessionPaths(dataDir, sessionId)
+  const value = readJson(baseline, emptyBaseline())
+  return {
+    files:
+      value?.files && typeof value.files === 'object' && !Array.isArray(value.files)
+        ? value.files
+        : {},
+  }
+}
+
+function writeBaseline(dataDir, sessionId, baseline) {
+  const { baseline: file } = sessionPaths(dataDir, sessionId)
+  atomicWrite(file, `${JSON.stringify({ files: baseline.files ?? {} }, null, 2)}\n`)
+}
+
+function pruneEmptyDirs(targetRoot, filePath) {
+  const root = path.resolve(targetRoot)
+  let current = path.dirname(filePath)
+  while (current.startsWith(`${root}${path.sep}`)) {
+    if (!fs.existsSync(current)) {
+      current = path.dirname(current)
+      continue
+    }
+    if (fs.readdirSync(current).length > 0) break
+    fs.rmdirSync(current)
+    current = path.dirname(current)
+  }
+}
+
+export function captureBaseline(dataDir, sessionId, targetRoot, fileIds = []) {
+  const paths = sessionPaths(dataDir, sessionId)
+  const baseline = readBaseline(dataDir, sessionId)
+  let changed = false
+  for (const fileId of fileIds) {
+    const { id, absolute } = resolveTargetFile(targetRoot, fileId)
+    if (baseline.files[id]) continue
+    const existed = fs.existsSync(absolute) && fs.statSync(absolute).isFile()
+    baseline.files[id] = { existed }
+    if (existed) {
+      const stored = resolveTargetFile(paths.baselineFiles, id).absolute
+      fs.mkdirSync(path.dirname(stored), { recursive: true })
+      fs.copyFileSync(absolute, stored)
+    }
+    changed = true
+  }
+  if (changed) writeBaseline(dataDir, sessionId, baseline)
+  return baseline
+}
+
+export function restoreBaseline(dataDir, sessionId, targetRoot) {
+  const paths = sessionPaths(dataDir, sessionId)
+  const baseline = readBaseline(dataDir, sessionId)
+  for (const [fileId, info] of Object.entries(baseline.files)) {
+    const { absolute } = resolveTargetFile(targetRoot, fileId)
+    if (!info?.existed) {
+      fs.rmSync(absolute, { force: true })
+      pruneEmptyDirs(targetRoot, absolute)
+      continue
+    }
+    const stored = resolveTargetFile(paths.baselineFiles, fileId).absolute
+    fs.mkdirSync(path.dirname(absolute), { recursive: true })
+    fs.copyFileSync(stored, absolute)
+  }
+}
+
+function replayPatches(dataDir, sessionId, targetRoot, entries) {
+  for (const entry of entries) {
+    applyUnifiedPatch(readDiff(dataDir, sessionId, entry), targetRoot)
+  }
+}
+
+function acceptedEntries(manifest) {
+  return manifest.diffs.filter((entry) => entry.status === 'applied')
+}
+
+function liveEntries(manifest, diffId) {
+  return chainThrough(manifest, diffId).filter((entry) => entry.status !== 'rejected')
+}
+
+export function materializeDiff(dataDir, targetRoot, sessionId, diffId) {
+  const manifest = readManifest(dataDir, assertSessionId(sessionId))
+  if (!manifest) throw new Error(`Unknown session ${sessionId}`)
+  const through = diffId || manifest.activeDiffId
+  if (!through) return manifest
+  restoreBaseline(dataDir, sessionId, targetRoot)
+  replayPatches(dataDir, sessionId, targetRoot, liveEntries(manifest, through))
+  return manifest
+}
+
+function withSessionReplay(dataDir, sessionId, targetRoot, patches, action) {
   const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'visual-coder-chain-'))
   try {
     fs.cpSync(targetRoot, temporary, { recursive: true })
+    restoreBaseline(dataDir, sessionId, temporary)
     for (const patchText of patches) applyUnifiedPatch(patchText, temporary)
     return action(temporary)
   } finally {
@@ -317,10 +431,28 @@ function withVirtualTarget(targetRoot, patches, action) {
 }
 
 export function validateContinuation(dataDir, manifest, targetRoot, patchText) {
-  const prior = unresolvedEntries(manifest).map((entry) =>
-    readDiff(dataDir, manifest.sessionId, entry),
+  const prior = manifest.diffs
+    .filter((entry) => entry.status !== 'rejected')
+    .map((entry) => readDiff(dataDir, manifest.sessionId, entry))
+  withSessionReplay(dataDir, manifest.sessionId, targetRoot, [...prior, patchText], () =>
+    undefined,
   )
-  withVirtualTarget(targetRoot, [...prior, patchText], () => undefined)
+}
+
+export function inspectTargetFile(
+  dataDir,
+  targetRoot,
+  { sessionId, diffId, fileId } = {},
+) {
+  if (sessionId && readManifest(dataDir, sessionId)) {
+    materializeDiff(dataDir, targetRoot, sessionId, diffId)
+  }
+  if (!fileId) return null
+  const { absolute } = resolveTargetFile(targetRoot, fileId)
+  if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) {
+    throw new Error(`File ${fileId} is not on disk`)
+  }
+  return absolute
 }
 
 function planSteps(titles, startAt = 1) {
@@ -555,6 +687,12 @@ export function appendDiff(dataDir, targetRoot, input) {
   }
 
   validateContinuation(dataDir, manifest, targetRoot, input.patchText)
+  captureBaseline(
+    dataDir,
+    sessionId,
+    targetRoot,
+    parseUnifiedPatch(input.patchText).entries.map((entry) => entry.id),
+  )
   if (parent?.status === 'extend') parent.status = 'extended'
 
   const id = String(manifest.diffs.length + 1).padStart(4, '0')
@@ -581,6 +719,7 @@ export function appendDiff(dataDir, targetRoot, input) {
   manifest.workStartedAt = null
   manifest.diffs.push(entry)
   writeManifest(dataDir, manifest)
+  materializeDiff(dataDir, targetRoot, sessionId, id)
   focusSession(dataDir, sessionId)
   return { manifest, entry }
 }
@@ -601,25 +740,7 @@ function pendingActive(manifest, diffId) {
 
 function applyUnresolved(dataDir, targetRoot, manifest, diffId) {
   const unresolved = unresolvedEntries(manifest, diffId)
-  const patches = unresolved.map((entry) =>
-    readDiff(dataDir, manifest.sessionId, entry),
-  )
-  const touched = new Set()
-  for (const patch of patches) {
-    for (const entry of parseUnifiedPatch(patch).entries) touched.add(entry.id)
-  }
-  withVirtualTarget(targetRoot, patches, (virtualRoot) => {
-    for (const id of touched) {
-      const source = path.join(virtualRoot, id)
-      const destination = path.join(targetRoot, id)
-      if (!fs.existsSync(source)) {
-        fs.rmSync(destination, { recursive: true, force: true })
-        continue
-      }
-      fs.mkdirSync(path.dirname(destination), { recursive: true })
-      fs.copyFileSync(source, destination)
-    }
-  })
+  materializeDiff(dataDir, targetRoot, manifest.sessionId, diffId)
   for (const entry of unresolved) {
     entry.status = 'applied'
     entry.decidedAt = new Date().toISOString()
@@ -663,8 +784,14 @@ export function requestReplan(dataDir, sessionId, diffId, instruction) {
   return manifest
 }
 
-export function stopSession(dataDir, sessionId, _diffId) {
-  finalizeFinishedSession(dataDir, sessionId)
+export function stopSession(dataDir, sessionId, targetRoot = null) {
+  const safeId = assertSessionId(sessionId)
+  const manifest = readManifest(dataDir, safeId)
+  if (manifest && targetRoot) {
+    restoreBaseline(dataDir, safeId, targetRoot)
+    replayPatches(dataDir, safeId, targetRoot, acceptedEntries(manifest))
+  }
+  finalizeFinishedSession(dataDir, safeId)
   return null
 }
 
@@ -682,7 +809,7 @@ export function decideDiff(
   if (decision === 'extend') {
     return requestReplan(dataDir, sessionId, diffId, instruction)
   }
-  return stopSession(dataDir, sessionId, diffId)
+  return stopSession(dataDir, sessionId, targetRoot)
 }
 
 export function closeSession(dataDir, sessionId) {

package/apps/explorer/src/App.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Canvas } from '@react-three/fiber'
-import { emptyIntent, fetchAgentIntent, performAgentAction, persistSessionBlueprint } from './agentIntent'
+import { emptyIntent, fetchAgentIntent, inspectTargetFile, performAgentAction, persistSessionBlueprint } from './agentIntent'
 import { fetchCodebase } from './codebase'
 import {
   layoutWorld,
@@ -163,6 +163,7 @@ function Explorer({
   ])
   const walkPos = useRef<[number, number]>([layout.spawn[0], layout.spawn[2]])
   const [selectedId, setSelectedId] = useState<string | null>(null)
+  const [selectedTick, setSelectedTick] = useState(0)
   const [selectedFolder, setSelectedFolder] = useState<string | null>(null)
   const [aimedRelation, setAimedRelation] = useState<AimedRelation | null>(null)
   const [flyTo, setFlyTo] = useState<FlyTo | null>(null)
@@ -274,7 +275,7 @@ function Explorer({
         browsingHistory.current = false
         lastIntentSig.current = intentSignature(next)
         applyIntent(next)
-        if (action === 'invoke' || action === 'continue') {
+        if (action === 'invoke' || action === 'continue' || action === 'stop') {
           await onRefreshGraph()
         }
       } catch {
@@ -300,6 +301,16 @@ function Explorer({
       try {
         const latest = intent.chain.at(-1)?.id
         browsingHistory.current = diffId !== latest
+        if (intent.sessionId) {
+          try {
+            await inspectTargetFile({
+              sessionId: intent.sessionId,
+              diffId,
+            })
+          } catch {
+            // Still show the historical preview if disk replay failed.
+          }
+        }
         const next = await fetchAgentIntent(diffId)
         lastIntentSig.current = intentSignature(next)
         applyIntent(next)
@@ -307,7 +318,22 @@ function Explorer({
         // Keep the current chain position if navigation failed.
       }
     },
-    [applyIntent, intent.chain],
+    [applyIntent, intent.chain, intent.sessionId],
+  )
+
+  const inspectFile = useCallback(
+    async (fileId: string) => {
+      try {
+        await inspectTargetFile({
+          sessionId: intent.sessionId,
+          diffId: intent.diffId,
+          fileId,
+        })
+      } catch {
+        // Keep the current view if the editor could not open the file.
+      }
+    },
+    [intent.diffId, intent.sessionId],
   )
 
   useEffect(() => {
@@ -566,7 +592,10 @@ function Explorer({
   const selectFile = useCallback(
     (fileId: string | null) => {
       setSelectedId(fileId)
-      if (fileId) setSelectedFolder(null)
+      if (fileId) {
+        setSelectedFolder(null)
+        setSelectedTick((tick) => tick + 1)
+      }
       if (fileId && intent.creationMode) document.exitPointerLock()
     },
     [intent.creationMode],
@@ -904,6 +933,7 @@ function Explorer({
         mode={mode}
         locked={locked}
         selectedId={selectedId}
+        selectedTick={selectedTick}
         selectedFolder={selectedFolder}
         aimedRelation={aimedRelation}
         currentFolder={currentFolder}
@@ -935,6 +965,7 @@ function Explorer({
         onRemoveBlueprintImport={removeBlueprintImport}
         onMapAddFile={placeBlockOnFolder}
         onMapAddFolder={placeIslandOnFolder}
+        onInspectFile={inspectFile}
       />
     </>
   )

package/apps/explorer/src/agentIntent.ts

@@ -180,3 +180,24 @@ export function persistSessionBlueprint(
     // Keep local drafts if the session handshake is no longer open.
   })
 }
+
+export async function inspectTargetFile(payload: {
+  sessionId?: string | null
+  diffId?: string | null
+  fileId?: string
+}) {
+  const response = await fetch('/api/inspect-file', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) {
+    const detail = await response.text()
+    throw new Error(detail || 'Could not inspect file')
+  }
+  return (await response.json()) as {
+    path: string | null
+    uri: string | null
+    opened: boolean
+  }
+}