@lucenaone/coder 1.0.0 → 1.1.1

package/.WorkspaceBrain/workspace.json

@@ -0,0 +1,4 @@
+{
+  "name": "lucenacoder",
+  "createdAt": "2026-05-24T01:17:13.939Z"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucenaone/coder",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Private tunnel for connecting LucenaCoder.com to your local folder. Always remains folder scoped while providing full terminal access.",
   "type": "module",
   "bin": {
@@ -10,10 +10,16 @@
     "start": "node bin/lucena.js"
   },
   "dependencies": {
+    "chokidar": "^4.0.0",
     "firebase": "^11.0.0",
-    "chokidar": "^4.0.0"
+    "web-tree-sitter": "^0.26.9"
   },
-  "keywords": ["lucena", "lucenacoder", "tunnel", "lucenaone"],
+  "keywords": [
+    "lucena",
+    "lucenacoder",
+    "tunnel",
+    "lucenaone"
+  ],
   "author": "LucenaOne",
   "license": "MIT"
-}
+}

package/src/agent.js

@@ -3,13 +3,14 @@ import { getDatabase, ref, push, set, onChildAdded, onDisconnect, serverTimestam
 import { spawn } from 'child_process';
 import { watch } from 'chokidar';
 import { readFile, writeFile, mkdir, readdir, stat, unlink, rm } from 'fs/promises';
-import { join, resolve, dirname, basename, relative, isAbsolute } from 'path';
-import { existsSync } from 'fs';
+import { join, resolve, dirname, basename, relative, isAbsolute, extname } from 'path';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { FIREBASE_CONFIG } from './config.js';
+import { buildIndex, reindexFile } from './cli-indexer.js';
 
 const IGNORED_PATTERNS = [
   'node_modules', '.git', '.next', '.wrangler', '.DS_Store',
-  'dist', 'build', '.cache', '.turbo', '.vercel', '.firebase', 'Users'
+  'dist', 'build', '.cache', '.turbo', '.vercel', '.firebase'
 ];
 
 // ── The CLI Jailer ──
@@ -36,6 +37,19 @@ function getJailedPath(baseDir, rawPath) {
   return resolve(baseDir, safeParts.join('/'));
 }
 
+// ── Path Sanitizer ──
+// Strips the absolute cwd from any text output so the AI never sees
+// real filesystem paths. Replaces /Users/whoever/projects/foo with /
+function stripCwd(cwd, text) {
+  if (!text || typeof text !== 'string') return text;
+  // Normalize both to forward-slash form for reliable matching
+  const normalized = cwd.replace(/\\/g, '/');
+  // Escape regex special chars in the path
+  const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // Replace the absolute path (with or without trailing slash) with just /
+  return text.replace(new RegExp(escaped + '/?', 'g'), '/');
+}
+
 export class LucenaAgent {
   constructor(cwd) {
     this.cwd = resolve(cwd);
@@ -45,9 +59,49 @@ export class LucenaAgent {
     this.watcher = null;
     this.activeCommands = new Map();
     this.connected = false;
+    this.indexData = null; // Pre-built index from CLI-side parsing
+    this.indexPromise = null; // The in-flight indexing promise
+  }
+
+  _scaffoldWorkspaceBrain() {
+    const brainDir = join(this.cwd, '.WorkspaceBrain');
+    const subdirs = ['memories', 'skills', 'threads'];
+    try {
+      if (!existsSync(brainDir)) mkdirSync(brainDir, { recursive: true });
+      for (const sub of subdirs) {
+        const subPath = join(brainDir, sub);
+        if (!existsSync(subPath)) mkdirSync(subPath, { recursive: true });
+      }
+      // Scaffold workspace.json if it doesn't exist
+      const wsJson = join(brainDir, 'workspace.json');
+      if (!existsSync(wsJson)) {
+        writeFileSync(wsJson, JSON.stringify({ name: basename(this.cwd), createdAt: new Date().toISOString() }, null, 2));
+      }
+    } catch (err) {
+      // Non-fatal — the brain is best-effort
+      console.warn('[workspace-brain] scaffold failed:', err.message);
+    }
   }
 
   async start() {
+    // Ensure .WorkspaceBrain/ exists on disk with subdirectories
+    this._scaffoldWorkspaceBrain();
+
+    // ── Start indexing immediately on the CLI machine ──
+    this.indexPromise = buildIndex(this.cwd, (progress) => {
+      if (progress.phase === 'parsing' && progress.current > 0) {
+        process.stdout.write(`\r  ${'\x1b[90m'}⏳ Indexing... ${progress.current}/${progress.total} files${'\x1b[0m'}`);
+      }
+    }).then((result) => {
+      this.indexData = result;
+      const { stats } = result;
+      process.stdout.write(`\r  ${'\x1b[32m'}✔ Indexed ${stats.filesParsed} files — ${stats.symbolCount} symbols, ${stats.stringCount} strings${'\x1b[0m'}  \n`);
+      return result;
+    }).catch((err) => {
+      console.warn(`\n  ${'\x1b[33m'}⚠ Indexing failed: ${err.message}${'\x1b[0m'}`);
+      return null;
+    });
+
     this.app = initializeApp(FIREBASE_CONFIG, `agent-${this.tunnelId}`);
     this.db = getDatabase(this.app);
     const tunnelRef = ref(this.db, `tunnels/${this.tunnelId}`);
@@ -55,8 +109,7 @@ export class LucenaAgent {
     await set(tunnelRef, {
       meta: {
         createdAt: serverTimestamp(),
-        cwd: this.cwd,
-        cwdName: basename(this.cwd),
+        cwdName: basename(this.cwd),  // Never expose full cwd to the browser
         status: 'active',
         pid: process.pid,
         platform: process.platform
@@ -69,6 +122,20 @@ export class LucenaAgent {
     onDisconnect(presenceRef).set(false);
     onDisconnect(ref(this.db, `tunnels/${this.tunnelId}/meta/status`)).set('disconnected');
 
+    // ── Listen for browser connect events ──
+    // When the browser connects, push the pre-built index immediately
+    const connectRef = ref(this.db, `tunnels/${this.tunnelId}/meta/browserConnected`);
+    onChildAdded(ref(this.db, `tunnels/${this.tunnelId}/browserConnect`), async (snapshot) => {
+      const data = snapshot.val();
+      if (!data) return;
+      remove(snapshot.ref);
+      
+      // Index is guaranteed ready (awaited in start()), push immediately
+      if (this.indexData) {
+        this.pushIndexSnapshot(this.indexData);
+      }
+    });
+
     const commandsRef = ref(this.db, `tunnels/${this.tunnelId}/commands`);
     onChildAdded(commandsRef, async (snapshot) => {
       const command = snapshot.val();
@@ -78,15 +145,51 @@ export class LucenaAgent {
       try {
         await this.handleCommand(command);
       } catch (err) {
-        this.pushResponse(command.messageId, 'error', err.message);
+        this.pushResponse(command.messageId, 'error', stripCwd(this.cwd, err.message));
       }
     });
 
     this.startWatcher();
     this.connected = true;
+
+    // ── Wait for indexing to finish before opening the browser ──
+    // This guarantees the snapshot is ready the instant the browser connects
+    await this.indexPromise;
+
     return this.tunnelId;
   }
 
+  // ── Push the full pre-built index to the browser via RTDB ──
+  pushIndexSnapshot(index) {
+    const snapshotRef = ref(this.db, `tunnels/${this.tunnelId}/indexSnapshot`);
+    // Push as a single message — the browser hydrates from this
+    set(snapshotRef, {
+      symbols: index.symbols,
+      strings: index.strings,
+      stats: index.stats,
+      timestamp: serverTimestamp(),
+    });
+    console.log(`  ${'\x1b[36m'}📡 Index snapshot pushed to browser${'\x1b[0m'}`);
+  }
+
+  // ── Push an incremental delta when a file changes ──
+  async pushIndexDelta(relPath) {
+    const ext = extname(relPath);
+    const SUPPORTED_EXTS = ['.js', '.jsx', '.ts', '.tsx', '.py', '.rb', '.go', '.rs'];
+    if (!SUPPORTED_EXTS.includes(ext)) return;
+
+    const delta = await reindexFile(this.cwd, '/' + relPath);
+    if (!delta) return;
+
+    const deltaRef = ref(this.db, `tunnels/${this.tunnelId}/indexDeltas`);
+    push(deltaRef, {
+      filePath: delta.filePath,
+      symbols: delta.symbols,
+      strings: delta.strings,
+      timestamp: serverTimestamp(),
+    });
+  }
+
   async handleCommand(command) {
     const { type, messageId } = command;
     switch (type) {
@@ -117,8 +220,12 @@ export class LucenaAgent {
   async executeCommand({ messageId, command }) {
     const child = spawn('sh', ['-c', command], { cwd: this.cwd });
 
-    child.stdout.on('data', (data) => this.pushResponse(messageId, 'output', data.toString()));
-    child.stderr.on('data', (data) => this.pushResponse(messageId, 'output', data.toString()));
+    child.stdout.on('data', (data) => {
+      this.pushResponse(messageId, 'output', stripCwd(this.cwd, data.toString()));
+    });
+    child.stderr.on('data', (data) => {
+      this.pushResponse(messageId, 'output', stripCwd(this.cwd, data.toString()));
+    });
     child.on('close', (code) => {
       this.pushResponse(messageId, 'done', '', { exitCode: code ?? 0 });
       this.activeCommands.delete(messageId);
@@ -134,18 +241,19 @@ export class LucenaAgent {
       this.pushResponse(messageId, 'output', content);
       this.pushResponse(messageId, 'done', '');
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
   async writeFileCmd({ messageId, path: filePath, content }) {
     const fullPath = getJailedPath(this.cwd, filePath);
+    const relPath = '/' + relative(this.cwd, fullPath);
     try {
       await mkdir(dirname(fullPath), { recursive: true });
       await writeFile(fullPath, content, 'utf-8');
-      this.pushResponse(messageId, 'done', `Wrote ${fullPath}`);
+      this.pushResponse(messageId, 'done', `Wrote ${relPath}`);
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
@@ -159,7 +267,7 @@ export class LucenaAgent {
         .join('\n');
       this.pushResponse(messageId, 'done', listing || '(empty)');
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
@@ -175,31 +283,33 @@ export class LucenaAgent {
         created: s.birthtime
       }));
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
   async deleteFile({ messageId, path: filePath }) {
     const fullPath = getJailedPath(this.cwd, filePath);
+    const relPath = '/' + relative(this.cwd, fullPath);
     try {
       if ((await stat(fullPath)).isDirectory()) {
         await rm(fullPath, { recursive: true });
       } else {
         await unlink(fullPath);
       }
-      this.pushResponse(messageId, 'done', `Deleted ${fullPath}`);
+      this.pushResponse(messageId, 'done', `Deleted ${relPath}`);
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
   async mkdirCmd({ messageId, path: dirPath }) {
     const fullPath = getJailedPath(this.cwd, dirPath);
+    const relPath = '/' + relative(this.cwd, fullPath);
     try {
       await mkdir(fullPath, { recursive: true });
-      this.pushResponse(messageId, 'done', `Created ${fullPath}`);
+      this.pushResponse(messageId, 'done', `Created ${relPath}`);
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
@@ -216,10 +326,10 @@ export class LucenaAgent {
       child.stderr.on('data', (d) => { output += d.toString(); });
 
       child.on('close', (code) => {
-        this.pushResponse(messageId, 'done', output || 'No matches found');
+        this.pushResponse(messageId, 'done', stripCwd(this.cwd, output) || 'No matches found');
       });
     } catch (err) {
-      this.pushResponse(messageId, 'error', err.message);
+      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
     }
   }
 
@@ -244,6 +354,11 @@ export class LucenaAgent {
         path: relPath,
         timestamp: serverTimestamp()
       });
+
+      // ── Push incremental index delta for changed files ──
+      if (event === 'change' || event === 'add') {
+        this.pushIndexDelta(relPath).catch(() => {}); // Non-blocking, non-fatal
+      }
     });
   }
 

package/src/cli-indexer.js

@@ -0,0 +1,466 @@
+// src/cli-indexer.js — Tree-sitter WASM indexer for the CLI agent
+// Runs on the user's machine at startup, parses all code files locally,
+// and builds a symbol + string index that can be pushed to the browser
+// via RTDB when the tunnel connects.
+
+import { readFile, readdir } from 'fs/promises';
+import { join, extname, relative } from 'path';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ── Language Support ──
+const LANGUAGE_MAP = {
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.ts': 'typescript',
+  '.tsx': 'tsx',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.go': 'go',
+  '.rs': 'rust',
+};
+
+const IGNORED_PATTERNS = [
+  'node_modules', '.git', '.next', '.wrangler', '.DS_Store',
+  'dist', 'build', '.cache', '.turbo', '.vercel', '.firebase',
+  '.WorkspaceBrain',
+];
+
+// ── Parser singleton ──
+let _Parser = null;
+let _Language = null;
+let isInitialized = false;
+const languageCache = new Map();
+
+function getGrammarsDir() {
+  return join(__dirname, '..', 'grammars');
+}
+
+async function initParser() {
+  if (isInitialized) return;
+  const mod = await import('web-tree-sitter');
+  _Parser = mod.Parser;
+  _Language = mod.Language;
+
+  const grammarsDir = getGrammarsDir();
+
+  await _Parser.init({
+    locateFile: (scriptName) => {
+      return join(grammarsDir, scriptName);
+    },
+  });
+  isInitialized = true;
+}
+
+async function loadLanguage(langExt) {
+  if (languageCache.has(langExt)) return languageCache.get(langExt);
+
+  const langName = LANGUAGE_MAP[langExt];
+  if (!langName) throw new Error(`Unsupported language: ${langExt}`);
+
+  const grammarsDir = getGrammarsDir();
+  const wasmFile = join(grammarsDir, `tree-sitter-${langName}.wasm`);
+  const language = await _Language.load(wasmFile);
+  languageCache.set(langExt, language);
+  return language;
+}
+
+// ── Chunk Extraction (mirrors ast-worker.js exactly) ──
+
+function extractChunks(rootNode, code) {
+  const chunks = [];
+  const strings = [];
+
+  function walk(node, depth, parentType) {
+    const type = node.type;
+
+    // ── Imports ──
+    if (type === 'import_declaration' || type === 'import_statement' || type === 'import_from_statement') {
+      chunks.push({
+        type: 'import',
+        name: node.text.slice(0, 80),
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Classes ──
+    if (type === 'class_declaration' || type === 'class_definition' || type === 'class') {
+      const nameNode = node.childForFieldName('name');
+      const name = nameNode ? nameNode.text : '<anonymous>';
+      const isExported = isExportedNode(node);
+      chunks.push({
+        type: 'class',
+        name,
+        exported: isExported,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractNestedNames(node, chunks, name);
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Function declarations ──
+    if (type === 'function_declaration' || type === 'function_definition' || type === 'method_definition') {
+      if (depth > 1) {
+        extractStringsFromNode(node, strings);
+        return;
+      }
+      const nameNode = node.childForFieldName('name');
+      const name = nameNode ? nameNode.text : '<anonymous>';
+      const isExported = isExportedNode(node) || isExportedNode(node.parent);
+      chunks.push({
+        type: 'function',
+        name,
+        exported: isExported,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Variable declarations (top-level only) ──
+    if ((type === 'variable_declarator' || type === 'variable_declaration' || type === 'lexical_declaration') && depth === 0) {
+      if (type === 'variable_declaration' || type === 'lexical_declaration') {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child.type === 'variable_declarator') {
+            const nameNode = child.childForFieldName('name');
+            const valueNode = child.childForFieldName('value');
+            const name = nameNode ? nameNode.text : '<unknown>';
+            const isArrowFn = valueNode && (valueNode.type === 'arrow_function' || valueNode.type === 'function');
+            const isExported = isExportedNode(node);
+            chunks.push({
+              type: isArrowFn ? 'function' : 'variable',
+              name,
+              exported: isExported,
+              startByte: node.startIndex,
+              endByte: node.endIndex,
+              text: node.text,
+            });
+          }
+        }
+        extractStringsFromNode(node, strings);
+        return;
+      }
+
+      const nameNode = node.childForFieldName('name');
+      const valueNode = node.childForFieldName('value');
+      const name = nameNode ? nameNode.text : '<unknown>';
+      const isArrowFn = valueNode && (valueNode.type === 'arrow_function' || valueNode.type === 'function');
+      const isExported = isExportedNode(node.parent);
+      chunks.push({
+        type: isArrowFn ? 'function' : 'variable',
+        name,
+        exported: isExported,
+        startByte: node.parent ? node.parent.startIndex : node.startIndex,
+        endByte: node.parent ? node.parent.endIndex : node.endIndex,
+        text: node.parent ? node.parent.text : node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Python assignments at top level ──
+    if (type === 'assignment' && depth === 0) {
+      const leftNode = node.childForFieldName('left');
+      const name = leftNode ? leftNode.text : '<unknown>';
+      chunks.push({
+        type: 'variable',
+        name,
+        exported: false,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Go top-level var/const ──
+    if ((type === 'var_declaration' || type === 'const_declaration') && depth === 0) {
+      chunks.push({
+        type: 'variable',
+        name: node.text.slice(0, 60),
+        exported: false,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Ruby method definitions ──
+    if (type === 'method' || type === 'singleton_method') {
+      const nameNode = node.childForFieldName('name');
+      const name = nameNode ? nameNode.text : '<anonymous>';
+      chunks.push({
+        type: 'function',
+        name,
+        exported: false,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Rust function definitions ──
+    if (type === 'function_item' || type === 'function_signature_item') {
+      const nameNode = node.childForFieldName('name');
+      const name = nameNode ? nameNode.text : '<anonymous>';
+      const isExported = isExportedNode(node) || isExportedNode(node.parent);
+      chunks.push({
+        type: 'function',
+        name,
+        exported: isExported,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Rust impl blocks ──
+    if (type === 'impl_item') {
+      const typeNode = node.childForFieldName('type');
+      const name = typeNode ? typeNode.text : '<impl>';
+      chunks.push({
+        type: 'class',
+        name,
+        exported: false,
+        startByte: node.startIndex,
+        endByte: node.endIndex,
+        text: node.text,
+      });
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Export statements wrapping other declarations ──
+    if (type === 'export_statement' || type === 'export_default_declaration') {
+      for (let i = 0; i < node.childCount; i++) {
+        walk(node.child(i), depth, type);
+      }
+      extractStringsFromNode(node, strings);
+      return;
+    }
+
+    // ── Continue walking children ──
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i), depth + 1, type);
+    }
+  }
+
+  walk(rootNode, 0, null);
+  return { chunks, strings };
+}
+
+function isExportedNode(node) {
+  if (!node) return false;
+  if (node.type === 'export_statement' || node.type === 'export_default_declaration') return true;
+  if (node.type === 'pub') return true; // Rust
+  if (node.parent && (node.parent.type === 'export_statement' || node.parent.type === 'export_default_declaration')) return true;
+  return false;
+}
+
+function extractNestedNames(node, chunks, parentName) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child.type === 'method_definition' || child.type === 'function_definition' || child.type === 'method') {
+      const nameNode = child.childForFieldName('name');
+      if (nameNode) {
+        chunks.push({
+          type: 'nested_function',
+          name: nameNode.text,
+          parent: parentName,
+          startByte: child.startIndex,
+          endByte: child.endIndex,
+          text: child.text,
+        });
+      }
+    }
+  }
+}
+
+function extractStringsFromNode(node, strings) {
+  const stringTypes = new Set([
+    'string', 'string_literal', 'template_string', 'template_literal',
+    'comment', 'line_comment', 'block_comment', 'jsx_text',
+  ]);
+
+  function walkStrings(n) {
+    if (stringTypes.has(n.type)) {
+      const text = n.text.trim();
+      if (text.length > 1 && text.length < 500) {
+        strings.push({
+          text,
+          startByte: n.startIndex,
+          endByte: n.endIndex,
+        });
+      }
+      return;
+    }
+    for (let i = 0; i < n.childCount; i++) {
+      walkStrings(n.child(i));
+    }
+  }
+
+  walkStrings(node);
+}
+
+// ── File Tree Walker ──
+
+async function walkDirectory(dirPath, cwd, results = []) {
+  const entries = await readdir(dirPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (IGNORED_PATTERNS.some(p => entry.name.includes(p))) continue;
+
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      await walkDirectory(fullPath, cwd, results);
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name);
+      if (LANGUAGE_MAP[ext]) {
+        results.push({
+          filePath: '/' + relative(cwd, fullPath),
+          fullPath,
+          ext,
+        });
+      }
+    }
+  }
+  return results;
+}
+
+// ── Main Index Builder ──
+
+export async function buildIndex(cwd, onProgress) {
+  await initParser();
+
+  const files = await walkDirectory(cwd, cwd);
+  const totalFiles = files.length;
+
+  if (onProgress) onProgress({ phase: 'parsing', current: 0, total: totalFiles });
+
+  // Symbol index: Array<{ name, filePath, type, exported, parent }>
+  const symbolEntries = [];
+  // String index: Array<{ text, filePath }>
+  const stringEntries = [];
+
+  let parsed = 0;
+  let errors = 0;
+
+  for (const file of files) {
+    try {
+      const code = await readFile(file.fullPath, 'utf-8');
+      const lang = await loadLanguage(file.ext);
+      const parser = new _Parser();
+      parser.setLanguage(lang);
+      const tree = parser.parse(code);
+      const { chunks, strings } = extractChunks(tree.rootNode, code);
+      tree.delete();
+
+      // Build symbol entries
+      for (const chunk of chunks) {
+        if (chunk.type === 'import') continue; // Skip imports for symbol index
+        symbolEntries.push({
+          name: chunk.name,
+          filePath: file.filePath,
+          type: chunk.type,
+          exported: chunk.exported || false,
+          parent: chunk.parent || null,
+        });
+      }
+
+      // Build string entries
+      for (const str of strings) {
+        stringEntries.push({
+          text: str.text,
+          filePath: file.filePath,
+        });
+      }
+
+      parsed++;
+      if (onProgress && parsed % 25 === 0) {
+        onProgress({ phase: 'parsing', current: parsed, total: totalFiles });
+      }
+    } catch (err) {
+      errors++;
+      console.error(`[cli-indexer] Error parsing ${file.filePath}: ${err.message}`);
+    }
+  }
+
+  if (onProgress) onProgress({ phase: 'done', current: parsed, total: totalFiles });
+
+  return {
+    symbols: symbolEntries,
+    strings: stringEntries,
+    stats: {
+      filesParsed: parsed,
+      filesErrored: errors,
+      symbolCount: symbolEntries.length,
+      stringCount: stringEntries.length,
+    },
+  };
+}
+
+// ── Single-file re-index (for incremental updates) ──
+
+export async function reindexFile(cwd, relPath) {
+  await initParser();
+
+  const ext = extname(relPath);
+  const langName = LANGUAGE_MAP[ext];
+  if (!langName) return null;
+
+  const fullPath = join(cwd, relPath.replace(/^\//, ''));
+  if (!existsSync(fullPath)) return { filePath: relPath, symbols: [], strings: [] };
+
+  try {
+    const code = await readFile(fullPath, 'utf-8');
+    const lang = await loadLanguage(ext);
+    const parser = new _Parser();
+    parser.setLanguage(lang);
+    const tree = parser.parse(code);
+    const { chunks, strings } = extractChunks(tree.rootNode, code);
+    tree.delete();
+
+    const symbolEntries = [];
+    for (const chunk of chunks) {
+      if (chunk.type === 'import') continue;
+      symbolEntries.push({
+        name: chunk.name,
+        filePath: relPath,
+        type: chunk.type,
+        exported: chunk.exported || false,
+        parent: chunk.parent || null,
+      });
+    }
+
+    const stringEntries = strings.map(s => ({
+      text: s.text,
+      filePath: relPath,
+    }));
+
+    return { filePath: relPath, symbols: symbolEntries, strings: stringEntries };
+  } catch (err) {
+    console.error(`[cli-indexer] Error re-indexing ${relPath}: ${err.message}`);
+    return null;
+  }
+}

package/src/main.js

@@ -42,7 +42,6 @@ export async function main() {
   console.log(`  ${c.cyan}📍 Scoped to:${c.reset} ${cwd}`);
   console.log(`  ${c.yellow}🛡️  Safe Mode:${c.reset} ON by default (All edits require approval)`);
   console.log(`               ${c.dim}Optionally switch to YOLO on LucenaCoder.com${c.reset}\n`);
-  console.log(`  Starting tunnel...`);
 
   const agent = new LucenaAgent(cwd);
 
@@ -56,8 +55,10 @@ export async function main() {
   process.on('SIGTERM', shutdown);
 
   try {
+    console.log(`  ${c.dim}⏳ Indexing workspace...${c.reset}`);
     const tunnelId = await agent.start();
-    console.log(`\n  ${c.green}✔ Tunnel active!${c.reset}\n`);
+    console.log(`  ${c.green}✔ Indexed${c.reset}\n`);
+    console.log(`  ${c.green}✔ Tunnel active!${c.reset}\n`);
     
     const idLabel = "Tunnel ID:";
     const boxWidth = idLabel.length + tunnelId.length + 5;