@jkwd/inbase 0.1.0

package/apps/explorer/vite.config.ts

@@ -0,0 +1,295 @@
+import { defineConfig, type Plugin } from 'vite'
+import react from '@vitejs/plugin-react'
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+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 { dataDir, targetRoot } from './scripts/target-config.mjs'
+import {
+  answerBlueprint,
+  continueDiff,
+  invokeStep,
+  readActiveSession,
+  requestReplan,
+  sendBlueprint,
+  sessionIntent,
+  stopSession,
+  updateBlueprint,
+} from './scripts/session-store.mjs'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const userContextFile = path.join(dataDir, 'user-context.json')
+const codebaseFile = path.join(dataDir, 'codebase.json')
+const scanScript = path.resolve(here, 'scripts/scan-target.mjs')
+
+// The rescan runs with cwd set to the explorer, so hand it the already-resolved
+// root and data dir instead of letting relative env values resolve differently.
+const scanEnv = {
+  ...process.env,
+  VISUAL_CODER_TARGET: targetRoot,
+  INBASE_DATA_DIR: dataDir,
+}
+
+function readBody(req: IncomingMessage) {
+  return new Promise<string>((resolve, reject) => {
+    const chunks: Buffer[] = []
+    req.on('data', (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+    })
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    req.on('error', reject)
+  })
+}
+
+function knownFileIds() {
+  try {
+    const graph = JSON.parse(fs.readFileSync(codebaseFile, 'utf8')) as {
+      files?: Array<{ id?: string }>
+    }
+    return Array.isArray(graph.files)
+      ? graph.files.map((file) => file.id).filter((id): id is string => Boolean(id))
+      : []
+  } catch {
+    return []
+  }
+}
+
+function sendJson(res: ServerResponse, status: number, body: unknown) {
+  res.statusCode = status
+  res.setHeader('Content-Type', 'application/json')
+  res.end(JSON.stringify(body))
+}
+
+function jsonFilePlugin(): Plugin {
+  return {
+    name: 'visual-coder-json-files',
+    configureServer(server) {
+      server.middlewares.use('/api/user-context', (req, res, next) => {
+        if (req.method === 'GET') {
+          sendJson(res, 200, readUserContext())
+          return
+        }
+        if (req.method === 'POST') {
+          void writeUserContext(req, res)
+          return
+        }
+        next()
+      })
+
+      server.middlewares.use('/api/codebase', (req, res, next) => {
+        if (req.method === 'GET') {
+          sendJson(res, 200, readCodebase())
+          return
+        }
+        next()
+      })
+
+      server.middlewares.use('/api/agent-intent', (req, res, next) => {
+        if (req.method === 'GET') {
+          const url = new URL(req.url ?? '/', 'http://visual-coder.local')
+          const sessionId = url.searchParams.get('sessionId') ?? readActiveSession(dataDir)
+          const diffId = url.searchParams.get('diffId') ?? undefined
+          const intent = sessionId
+            ? sessionIntent(dataDir, sessionId, knownFileIds(), diffId)
+            : null
+          sendJson(res, 200, intent ?? { ...emptyIntent })
+          return
+        }
+
+        if (req.method === 'POST') {
+          void decideIntent(req, res)
+          return
+        }
+
+        next()
+      })
+    },
+  }
+}
+
+async function decideIntent(req: IncomingMessage, res: ServerResponse) {
+  try {
+    const body = JSON.parse(await readBody(req)) as {
+      action?: string
+      sessionId?: string
+      diffId?: string
+      instruction?: string
+      step?: number
+      userCreatedBlocks?: unknown[]
+      userCreatedIslands?: unknown[]
+      addedFunctions?: unknown[]
+      addedVariables?: unknown[]
+      addedImports?: unknown[]
+    }
+    const action = body.action
+    if (
+      action !== 'invoke' &&
+      action !== 'continue' &&
+      action !== 'instruct' &&
+      action !== 'stop' &&
+      action !== 'blueprint_yes' &&
+      action !== 'blueprint_no' &&
+      action !== 'blueprint_send' &&
+      action !== 'blueprint_update'
+    ) {
+      sendJson(res, 400, { error: 'invalid workflow action' })
+      return
+    }
+    if (!body.sessionId) {
+      sendJson(res, 400, { error: 'sessionId is required' })
+      return
+    }
+    if (
+      body.instruction !== undefined &&
+      (typeof body.instruction !== 'string' || body.instruction.length > 4000)
+    ) {
+      sendJson(res, 400, { error: 'instruction must be a string up to 4000 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)
+      const scan = spawnSync(process.execPath, [scanScript], {
+        cwd: here,
+        encoding: 'utf8',
+        env: scanEnv,
+      })
+      if (scan.status !== 0) {
+        console.error(scan.stderr || scan.stdout || 'scan failed after invoking step')
+      }
+    } else if (action === 'continue') {
+      if (!body.diffId) {
+        sendJson(res, 400, { error: 'diffId is required for continue' })
+        return
+      }
+      continueDiff(dataDir, targetRoot, body.sessionId, body.diffId)
+      const scan = spawnSync(process.execPath, [scanScript], {
+        cwd: here,
+        encoding: 'utf8',
+        env: scanEnv,
+      })
+      if (scan.status !== 0) {
+        console.error(scan.stderr || scan.stdout || 'scan failed after applying patch')
+      }
+    } else if (action === 'instruct') {
+      if (!body.diffId) {
+        sendJson(res, 400, { error: 'diffId is required for instruct' })
+        return
+      }
+      requestReplan(
+        dataDir,
+        body.sessionId,
+        body.diffId,
+        body.instruction ?? '',
+      )
+    } else if (action === 'blueprint_yes') {
+      answerBlueprint(dataDir, body.sessionId, true)
+    } else if (action === 'blueprint_no') {
+      answerBlueprint(dataDir, body.sessionId, false)
+    } else if (action === 'blueprint_update') {
+      updateBlueprint(dataDir, body.sessionId, {
+        userCreatedBlocks: body.userCreatedBlocks,
+        userCreatedIslands: body.userCreatedIslands,
+        addedFunctions: body.addedFunctions,
+        addedVariables: body.addedVariables,
+        addedImports: body.addedImports,
+      })
+    } else if (action === 'blueprint_send') {
+      sendBlueprint(dataDir, body.sessionId, {
+        userCreatedBlocks: body.userCreatedBlocks,
+        userCreatedIslands: body.userCreatedIslands,
+        addedFunctions: body.addedFunctions,
+        addedVariables: body.addedVariables,
+        addedImports: body.addedImports,
+      })
+    } else {
+      stopSession(dataDir, body.sessionId, body.diffId)
+    }
+    const next = sessionIntent(dataDir, body.sessionId, knownFileIds())
+    sendJson(res, 200, next ?? { ...emptyIntent })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'invalid request'
+    sendJson(res, 400, { error: message })
+  }
+}
+
+function readCodebase() {
+  try {
+    return JSON.parse(fs.readFileSync(codebaseFile, 'utf8')) as {
+      root?: string
+      targetName?: string
+      files?: unknown[]
+      folders?: unknown[]
+    }
+  } catch {
+    return {
+      root: '.',
+      targetName: path.basename(targetRoot),
+      files: [],
+      folders: [
+        {
+          path: '.',
+          name: path.basename(targetRoot),
+          parent: null,
+          files: [],
+          children: [],
+        },
+      ],
+    }
+  }
+}
+
+function readUserContext() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(userContextFile, 'utf8')) as Record<
+      string,
+      unknown
+    >
+    return {
+      ...parsed,
+      followLook: Boolean(parsed.followLook),
+    }
+  } catch {
+    return { followLook: false }
+  }
+}
+
+async function writeUserContext(req: IncomingMessage, res: ServerResponse) {
+  try {
+    const incoming = JSON.parse(await readBody(req)) as Record<string, unknown>
+    const existing = readUserContext()
+    const next = {
+      ...existing,
+      ...incoming,
+      followLook:
+        typeof incoming.followLook === 'boolean'
+          ? incoming.followLook
+          : Boolean(existing.followLook),
+    }
+    delete next.userCreatedBlocks
+    delete next.userCreatedIslands
+    fs.mkdirSync(path.dirname(userContextFile), { recursive: true })
+    fs.writeFileSync(userContextFile, `${JSON.stringify(next, null, 2)}\n`)
+    res.statusCode = 204
+    res.end()
+  } catch {
+    res.statusCode = 400
+    res.end('invalid json')
+  }
+}
+
+export default defineConfig({
+  plugins: [react(), jsonFilePlugin()],
+  server: {
+    port: 5173,
+    fs: {
+      allow: [here, dataDir],
+    },
+  },
+})

package/bin/inbase.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import {
+  applyHostEnv,
+  copyDir,
+  ensureDataDir,
+  ensureGitignoreEntry,
+  explorerRoot,
+  skillTemplateDir,
+  takeFlagValue,
+} from './project.mjs'
+import {
+  proposePatch,
+  reportPlan,
+  startSession,
+  waitForApproval,
+  waitForBlueprint,
+} from './session.mjs'
+
+const HELP = `inbase — a first-person 3D map of a codebase
+
+Usage:
+  inbase init              Install the Cursor skill in this repo
+  inbase run               Scan this repo and start the local map
+  inbase help              Show this help
+
+Agent commands (used by the Cursor skill):
+  inbase start-session --session <id> [--feature "name"]
+  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> --clear
+
+Options for run:
+  --target <dir>           Project to map (default: current directory)
+  --port <number>          Dev server port (default: 5173)
+`
+
+function printHelp() {
+  console.log(HELP.trim())
+}
+
+export function initProject(projectRoot = process.cwd()) {
+  if (!fs.existsSync(skillTemplateDir)) {
+    throw new Error(`Inbase skill template missing at ${skillTemplateDir}`)
+  }
+  const skillDir = path.join(projectRoot, '.cursor/skills/inbase')
+  copyDir(skillTemplateDir, skillDir)
+  const { dataDir } = applyHostEnv({
+    cwd: projectRoot,
+    target: projectRoot,
+    dataDir: path.join(projectRoot, '.inbase'),
+  })
+  ensureDataDir(dataDir)
+  const gitignoreAdded = ensureGitignoreEntry(projectRoot)
+  return { skillDir, dataDir, gitignoreAdded }
+}
+
+function explorerHref(relative) {
+  return pathToFileURL(path.join(explorerRoot, relative)).href
+}
+
+async function runServer(args) {
+  const target = takeFlagValue(args, '--target')
+  const portValue = takeFlagValue(args, '--port')
+  const port = portValue ? Number(portValue) : 5173
+  if (portValue && !Number.isInteger(port)) {
+    console.error('inbase run --port must be an integer')
+    process.exit(1)
+  }
+
+  const { targetRoot, dataDir } = applyHostEnv({ target })
+  if (!fs.existsSync(targetRoot)) {
+    console.error(`Target not found at ${targetRoot}`)
+    process.exit(1)
+  }
+  ensureDataDir(dataDir)
+
+  const { scanTarget } = await import(explorerHref('scripts/scan-target.mjs'))
+  const { targetName } = await import(explorerHref('scripts/target-config.mjs'))
+  scanTarget({
+    root: targetRoot,
+    name: targetName,
+    dest: path.join(dataDir, 'codebase.json'),
+  })
+
+  const { createServer } = await import('vite')
+  const server = await createServer({
+    configFile: path.join(explorerRoot, 'vite.config.ts'),
+    root: explorerRoot,
+    server: {
+      port,
+      host: '127.0.0.1',
+      fs: {
+        allow: [explorerRoot, targetRoot, dataDir],
+      },
+    },
+  })
+  await server.listen()
+  const local = server.resolvedUrls?.local?.[0] ?? `http://localhost:${port}/`
+  console.log(`Inbase is mapping ${targetRoot}`)
+  console.log(`Open ${local}`)
+  console.log('Leave this running. In Cursor, the inbase skill talks to this server.')
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const [command, ...args] = argv
+  if (
+    !command ||
+    command === 'help' ||
+    command === '-h' ||
+    command === '--help'
+  ) {
+    printHelp()
+    return
+  }
+
+  if (command === 'init') {
+    const result = initProject()
+    console.log(`Installed Cursor skill at ${result.skillDir}`)
+    if (result.gitignoreAdded) console.log('Added .inbase/ to .gitignore')
+    console.log('Next: run `inbase run`, then ask Cursor to change source files.')
+    return
+  }
+
+  if (command === 'run') {
+    await runServer(args)
+    return
+  }
+
+  applyHostEnv()
+  ensureDataDir(process.env.INBASE_DATA_DIR)
+
+  if (command === 'start-session') {
+    await startSession(args)
+    return
+  }
+  if (command === 'wait-for-blueprint') {
+    await waitForBlueprint(args)
+    return
+  }
+  if (command === 'report-plan') {
+    await reportPlan(args)
+    return
+  }
+  if (command === 'wait-for-approval') {
+    await waitForApproval(args)
+    return
+  }
+  if (command === 'propose-patch') {
+    await proposePatch(args)
+    return
+  }
+
+  console.error(`Unknown command: ${command}\n`)
+  printHelp()
+  process.exitCode = 1
+}
+
+const invoked = process.argv[1] ? path.resolve(process.argv[1]) : ''
+if (invoked === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error)
+    process.exit(1)
+  })
+}

package/bin/project.mjs

@@ -0,0 +1,94 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+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 function resolveOptionalPath(value, fallback) {
+  const raw = value?.trim()
+  if (!raw) return fallback
+  return path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(process.cwd(), raw)
+}
+
+export function applyHostEnv({
+  cwd = process.cwd(),
+  target = process.env.VISUAL_CODER_TARGET,
+  dataDir = process.env.INBASE_DATA_DIR,
+} = {}) {
+  const targetRoot = resolveOptionalPath(target, cwd)
+  const resolvedDataDir = resolveOptionalPath(
+    dataDir,
+    path.join(targetRoot, '.inbase'),
+  )
+  process.env.VISUAL_CODER_TARGET = targetRoot
+  process.env.INBASE_DATA_DIR = resolvedDataDir
+  return { cwd, targetRoot, dataDir: resolvedDataDir }
+}
+
+export function ensureDataDir(dataDir) {
+  fs.mkdirSync(dataDir, { recursive: true })
+  const userContextFile = path.join(dataDir, 'user-context.json')
+  if (!fs.existsSync(userContextFile)) {
+    fs.writeFileSync(
+      userContextFile,
+      `${JSON.stringify({ followLook: false }, null, 2)}\n`,
+    )
+  }
+  return dataDir
+}
+
+export function takeFlagValue(args, flag) {
+  const index = args.indexOf(flag)
+  return index >= 0 ? args[index + 1] : null
+}
+
+export function takeFlagValues(args, flag) {
+  const values = []
+  const rest = []
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === flag && args[index + 1]) {
+      values.push(args[index + 1])
+      index += 1
+    } else {
+      rest.push(args[index])
+    }
+  }
+  return { values, rest }
+}
+
+export function withoutFlag(args, flag) {
+  return args.filter((arg) => arg !== flag)
+}
+
+export function copyDir(from, to) {
+  fs.mkdirSync(to, { recursive: true })
+  for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+    const source = path.join(from, entry.name)
+    const dest = path.join(to, entry.name)
+    if (entry.isDirectory()) {
+      copyDir(source, dest)
+      continue
+    }
+    fs.copyFileSync(source, dest)
+  }
+}
+
+export function ensureGitignoreEntry(projectRoot, entry = '.inbase/') {
+  const gitignore = path.join(projectRoot, '.gitignore')
+  const line = entry.endsWith('\n') ? entry : `${entry}\n`
+  if (!fs.existsSync(gitignore)) {
+    fs.writeFileSync(gitignore, line)
+    return true
+  }
+  const current = fs.readFileSync(gitignore, 'utf8')
+  const hasEntry = current
+    .split(/\r?\n/)
+    .some((row) => row.trim() === entry || row.trim() === entry.replace(/\/$/, ''))
+  if (hasEntry) return false
+  const prefix = current.endsWith('\n') || current === '' ? '' : '\n'
+  fs.appendFileSync(gitignore, `${prefix}${line}`)
+  return true
+}