@jkwd/inbase 0.1.15 → 0.1.16

package/README.md

@@ -49,11 +49,11 @@ inbase run --target /path/to/your/project
 
 Inbase does not call a model itself. The visual coding loop currently supports **Cursor**. The installed skill makes the agent work through the map: it reports a plan, waits on the **HUD** (heads-up display — the overlay panel on the 3D map), edits live files for each invoked step, and records that step as a patch. Those stored patches are the session record and are applied on every step update.
 
-Sessions start in the map: click **Setup LLM session**, type an **initial instruction**, optionally place a **blueprint** (`Space` for files, `B` for folders), then open a Cursor chat and run **`/inbase`**. That command connects the chat and starts the work. The layout is the source of truth for the chat. You can still place files and islands on later steps; they are stored on that chat’s blueprint. When the session finishes, placement stops and the session is discarded. Restarting the visualizer also starts with no LLM session; leftover session files are not restored.
+Sessions start in the map: click **Setup LLM session**, type an **initial instruction**, optionally place a **blueprint** (`Space` for files, `B` for folders), then open a Cursor chat and run **`/inbase`**. That command connects the chat and starts the work. The layout is the source of truth for the chat. The blueprint is shared across sessions and stays on the map even after those files and folders exist; use **Hide/Show blueprint**, **Clear blueprint**, or **Cleanup blueprint** (drops planned items that already exist). When a session finishes it is discarded; the shared blueprint remains. Restarting the visualizer also starts with no LLM session; leftover session files are not restored.
 
 A normal chat request does not open a session. Use `/inbase` after Setup LLM session, or `/skipinbase [request]` to work outside the map. `/inbase` starts the session immediately; `wait-for-blueprint` only reads the optional blueprint.
 
-If several sessions are open, `/inbase` attaches the newest session that is still waiting. Sessions that already have an LLM are skipped, and the map window does not need to be focused.
+If several sessions are open, `/inbase` attaches the oldest session that is still waiting. Sessions that already have an LLM are skipped, and the map window does not need to be focused.
 
 Turn on **Make LLM look where I look** if the agent should prefer the island you are standing on and the blocks you are facing. With **Step by step** on, click **Create proposal** to start a step, then **Accept proposal** when the patch is ready. With it off, the LLM implements the full plan; you can still walk Previous/Next over the diffs, then **Accept proposal**. Send an alternative instruction from the HUD to revise the remaining plan, or **Stop** to end the session.
 

package/apps/explorer/scripts/branch-changes.mjs

@@ -8,23 +8,10 @@ import {
   foldersFromFileIds,
   parseUnifiedPatch,
 } from './patch-lib.mjs'
+import { shouldIgnoreRelativePath, toPosix } from './scan-ignore.mjs'
 
-const SKIP_DIRS = new Set([
-  'node_modules',
-  'dist',
-  'build',
-  'out',
-  'coverage',
-  '.git',
-  '.inbase',
-])
-const SKIP_FILES = new Set(['package-lock.json'])
 const BINARY_PROBE_BYTES = 8000
 
-function toPosix(filePath) {
-  return filePath.split(path.sep).join('/')
-}
-
 function unique(ids) {
   return [...new Set(ids)]
 }
@@ -64,11 +51,7 @@ function isBinaryFile(filePath) {
 }
 
 function shouldSkipPath(fileId) {
-  const parts = fileId.split('/').filter(Boolean)
-  if (parts.some((part) => part.startsWith('.') || SKIP_DIRS.has(part))) {
-    return true
-  }
-  return SKIP_FILES.has(parts.at(-1) ?? '')
+  return shouldIgnoreRelativePath(fileId)
 }
 
 function currentBranch(cwd) {

package/apps/explorer/scripts/patch-lib.d.ts

@@ -114,12 +114,15 @@ export const emptyIntent: {
   initialInstruction: string | null
   creationMode: boolean
   canEnterBlueprint: boolean
+  blueprintHidden?: boolean
+  blueprintRevision?: number
   blueprintSessionId: string | null
   userCreatedBlocks: unknown[]
   userCreatedIslands: unknown[]
   blueprintFunctions: unknown[]
   blueprintVariables: unknown[]
   blueprintImports: unknown[]
+  blueprintNotes: unknown[]
 }
 
 export function isLastStep(intent: {

package/apps/explorer/scripts/patch-lib.mjs

@@ -541,12 +541,15 @@ export const emptyIntent = {
   initialInstruction: null,
   creationMode: false,
   canEnterBlueprint: false,
+  blueprintHidden: false,
+  blueprintRevision: 0,
   blueprintSessionId: null,
   userCreatedBlocks: [],
   userCreatedIslands: [],
   blueprintFunctions: [],
   blueprintVariables: [],
   blueprintImports: [],
+  blueprintNotes: [],
 }
 
 export function isLastStep(intent) {

package/apps/explorer/scripts/scan-ignore.mjs

@@ -0,0 +1,156 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+export const IGNORE_DIR_NAMES = new Set([
+  'node_modules',
+  'dist',
+  'build',
+  'out',
+  'coverage',
+  '.git',
+  '.inbase',
+])
+
+export const IGNORE_FILE_NAMES = new Set(['package-lock.json'])
+
+export function toPosix(filePath) {
+  return filePath.split(path.sep).join('/')
+}
+
+/** True when any path segment is ignored, e.g. apps/web/node_modules/pkg/index.js. */
+export function shouldIgnoreRelativePath(relative) {
+  const parts = toPosix(relative).split('/').filter(Boolean)
+  if (
+    parts.some(
+      (part) =>
+        IGNORE_DIR_NAMES.has(part) ||
+        (part.startsWith('.') && part !== '.' && part !== '..'),
+    )
+  ) {
+    return true
+  }
+  return IGNORE_FILE_NAMES.has(parts.at(-1) ?? '')
+}
+
+export function parseGitignore(text) {
+  const rules = []
+  for (const raw of text.split(/\r?\n/)) {
+    const trimmed = raw.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    let pattern = trimmed
+    const negated = pattern.startsWith('!')
+    if (negated) pattern = pattern.slice(1)
+    const dirOnly = pattern.endsWith('/')
+    if (dirOnly) pattern = pattern.slice(0, -1)
+    const fromRoot = pattern.startsWith('/')
+    if (fromRoot) pattern = pattern.slice(1)
+    const anchored = fromRoot || pattern.includes('/')
+    rules.push({ negated, dirOnly, anchored, pattern })
+  }
+  return rules
+}
+
+function globToRegExp(pattern) {
+  let source = '^'
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index]
+    if (char === '*' && pattern[index + 1] === '*') {
+      source += '.*'
+      index += 1
+      if (pattern[index + 1] === '/') index += 1
+      continue
+    }
+    if (char === '*') {
+      source += '[^/]*'
+      continue
+    }
+    if (char === '?') {
+      source += '[^/]'
+      continue
+    }
+    if ('\\.^$+{}()|[]'.includes(char)) source += `\\${char}`
+    else source += char
+  }
+  source += '(/.*)?$'
+  return new RegExp(source)
+}
+
+function ruleMatches(relative, rule) {
+  if (!rule.pattern) return false
+  if (rule.anchored || rule.pattern.includes('*') || rule.pattern.includes('?')) {
+    const source = rule.anchored ? rule.pattern : `**/${rule.pattern}`
+    return globToRegExp(source).test(relative) || globToRegExp(rule.pattern).test(relative)
+  }
+  const parts = relative.split('/').filter(Boolean)
+  if (rule.dirOnly) {
+    return parts.slice(0, -1).includes(rule.pattern) || relative === rule.pattern
+  }
+  return parts.includes(rule.pattern)
+}
+
+export function matchesGitignoreRules(relative, rules) {
+  const rel = toPosix(relative).replace(/^\/+/, '')
+  if (!rel) return false
+  let ignored = false
+  for (const rule of rules) {
+    if (ruleMatches(rel, rule)) ignored = !rule.negated
+  }
+  return ignored
+}
+
+export function readGitignoreRules(dir) {
+  try {
+    return parseGitignore(fs.readFileSync(path.join(dir, '.gitignore'), 'utf8'))
+  } catch {
+    return []
+  }
+}
+
+export function collectGitignoreSets(root) {
+  const resolved = path.resolve(root)
+  if (isIgnoredByEnclosingGitignore(resolved)) {
+    const rules = readGitignoreRules(resolved)
+    return rules.length ? [{ base: resolved, rules }] : []
+  }
+  const chain = [resolved]
+  let dir = resolved
+  while (!fs.existsSync(path.join(dir, '.git'))) {
+    const parent = path.dirname(dir)
+    if (parent === dir) {
+      const rules = readGitignoreRules(resolved)
+      return rules.length ? [{ base: resolved, rules }] : []
+    }
+    dir = parent
+    chain.push(dir)
+  }
+  const sets = []
+  for (const base of chain.reverse()) {
+    const rules = readGitignoreRules(base)
+    if (rules.length) sets.push({ base, rules })
+  }
+  return sets
+}
+
+function isIgnoredByEnclosingGitignore(resolved) {
+  let dir = path.dirname(resolved)
+  for (;;) {
+    const rules = readGitignoreRules(dir)
+    if (rules.length) {
+      const relative = toPosix(path.relative(dir, resolved))
+      if (relative && matchesGitignoreRules(relative, rules)) return true
+    }
+    if (fs.existsSync(path.join(dir, '.git'))) return false
+    const parent = path.dirname(dir)
+    if (parent === dir) return false
+    dir = parent
+  }
+}
+
+export function isIgnoredByGitignore(absolutePath, ignoreSets) {
+  for (const { base, rules } of ignoreSets) {
+    const relative = toPosix(path.relative(base, absolutePath))
+    if (!relative || relative.startsWith('..')) continue
+    if (matchesGitignoreRules(relative, rules)) return true
+  }
+  return false
+}

package/apps/explorer/scripts/scan-target.mjs

@@ -7,6 +7,13 @@ import {
   collectImportSpecifiers,
   extractJsSymbols,
 } from './js-source.mjs'
+import {
+  collectGitignoreSets,
+  isIgnoredByGitignore,
+  readGitignoreRules,
+  shouldIgnoreRelativePath,
+  toPosix,
+} from './scan-ignore.mjs'
 import {
   dataDir as defaultDataDir,
   targetName as defaultTargetName,
@@ -14,49 +21,78 @@ import {
 } from './target-config.mjs'
 
 const defaultOutPath = path.join(defaultDataDir, 'codebase.json')
-const IGNORE_DIRS = new Set([
-  'node_modules',
-  'dist',
-  'build',
-  'out',
-  'coverage',
-  '.git',
-  '.inbase',
-])
-const IGNORE_FILES = new Set(['package-lock.json'])
 const BINARY_PROBE_BYTES = 8000
 
-function toPosix(filePath) {
-  return filePath.split(path.sep).join('/')
+function isBinaryFile(filePath) {
+  try {
+    const fd = fs.openSync(filePath, 'r')
+    try {
+      const buf = Buffer.alloc(BINARY_PROBE_BYTES)
+      const bytes = fs.readSync(fd, buf, 0, buf.length, 0)
+      return buf.subarray(0, bytes).includes(0)
+    } finally {
+      fs.closeSync(fd)
+    }
+  } catch {
+    return true
+  }
 }
 
-function isBinaryFile(filePath) {
-  const fd = fs.openSync(filePath, 'r')
+function resolvesThroughIgnored(absolutePath, root) {
   try {
-    const buf = Buffer.alloc(BINARY_PROBE_BYTES)
-    const bytes = fs.readSync(fd, buf, 0, buf.length, 0)
-    return buf.subarray(0, bytes).includes(0)
-  } finally {
-    fs.closeSync(fd)
+    const real = fs.realpathSync(absolutePath)
+    const realRoot = fs.realpathSync(root)
+    if (!(real === realRoot || real.startsWith(realRoot + path.sep))) return true
+    return shouldIgnoreRelativePath(path.relative(realRoot, real))
+  } catch {
+    return true
   }
 }
 
-function walk(dir, acc = []) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith('.')) continue
-    if (entry.isDirectory()) {
-      if (IGNORE_DIRS.has(entry.name)) continue
-      walk(path.join(dir, entry.name), acc)
+function walk(dir, root, ignoreSets, acc = []) {
+  const localRules = readGitignoreRules(dir)
+  const nextSets = localRules.length
+    ? [...ignoreSets, { base: dir, rules: localRules }]
+    : ignoreSets
+  let entries
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return acc
+  }
+  for (const entry of entries) {
+    const absolutePath = path.join(dir, entry.name)
+    const relative = toPosix(path.relative(root, absolutePath))
+    if (
+      shouldIgnoreRelativePath(relative) ||
+      resolvesThroughIgnored(absolutePath, root) ||
+      isIgnoredByGitignore(absolutePath, nextSets)
+    ) {
       continue
     }
-    if (IGNORE_FILES.has(entry.name)) continue
-    const absolutePath = path.join(dir, entry.name)
+    let stat = entry
+    if (entry.isSymbolicLink()) {
+      try {
+        stat = fs.statSync(absolutePath)
+      } catch {
+        continue
+      }
+    }
+    if (stat.isDirectory()) {
+      walk(absolutePath, root, nextSets, acc)
+      continue
+    }
+    if (!stat.isFile()) continue
     if (isBinaryFile(absolutePath)) continue
     acc.push(absolutePath)
   }
   return acc
 }
 
+function listSourceAbsolutes(root) {
+  return walk(root, root, collectGitignoreSets(root))
+}
+
 function languageOf(filePath) {
   const ext = path.extname(filePath).slice(1).toLowerCase()
   return ext || 'txt'
@@ -140,7 +176,9 @@ function ensureFolder(folders, folderPath, rootName) {
 
 export function listSourceFiles(root) {
   if (!root || !fs.existsSync(root) || !fs.statSync(root).isDirectory()) return []
-  return walk(root).map((absolutePath) => toPosix(path.relative(root, absolutePath)))
+  return listSourceAbsolutes(root).map((absolutePath) =>
+    toPosix(path.relative(root, absolutePath)),
+  )
 }
 
 export function scanTarget({
@@ -154,7 +192,7 @@ export function scanTarget({
     )
   }
 
-  const absoluteFiles = walk(root)
+  const absoluteFiles = listSourceAbsolutes(root)
   const folders = new Map()
   ensureFolder(folders, '.', name)
 

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

@@ -133,6 +133,8 @@ export function readAttachedSession(dataDir: string): string | null
 export function listAttachQueue(dataDir: string): string[]
 export function nextAttachSessionId(dataDir: string): string | null
 export type SessionBlueprint = {
+  hidden: boolean
+  revision: number
   enabled: boolean
   sent: boolean
   userCreatedBlocks: unknown[]
@@ -140,14 +142,31 @@ export type SessionBlueprint = {
   addedFunctions: unknown[]
   addedVariables: unknown[]
   addedImports: unknown[]
+  notes: unknown[]
 }
 export function emptyBlueprint(): SessionBlueprint
-export function readBlueprint(dataDir: string, sessionId: string): SessionBlueprint
+export function readBlueprint(dataDir: string, sessionId?: string): SessionBlueprint
+export function writeBlueprint(
+  dataDir: string,
+  blueprint: SessionBlueprint,
+): SessionBlueprint
 export function writeBlueprint(
   dataDir: string,
   sessionId: string,
   blueprint: SessionBlueprint,
-): void
+): SessionBlueprint
+export function setBlueprintHidden(dataDir: string, hidden: boolean): SessionBlueprint
+export function clearBlueprint(dataDir: string): SessionBlueprint
+export function cleanupBlueprint(
+  dataDir: string,
+  knownFileIds?: string[],
+  knownFolderPaths?: string[],
+): SessionBlueprint
+export function markBlueprintSeen(
+  dataDir: string,
+  sessionId: string,
+  revision: number,
+): DiffManifest | null
 export function answerBlueprint(
   dataDir: string,
   sessionId: string,
@@ -155,13 +174,14 @@ export function answerBlueprint(
 ): DiffManifest
 export function updateBlueprint(
   dataDir: string,
-  sessionId: string,
+  sessionId?: string | null,
   input?: {
     userCreatedBlocks?: unknown[]
     userCreatedIslands?: unknown[]
     addedFunctions?: unknown[]
     addedVariables?: unknown[]
     addedImports?: unknown[]
+    notes?: unknown[]
   },
 ): SessionBlueprint
 export function sendBlueprint(
@@ -173,6 +193,7 @@ export function sendBlueprint(
     addedFunctions?: unknown[]
     addedVariables?: unknown[]
     addedImports?: unknown[]
+    notes?: unknown[]
   },
 ): DiffManifest
 export function maybeStartVisualizerHandshake(