vigthoria-cli 1.10.1 → 1.10.37

package/dist/utils/tools.d.ts

@@ -95,10 +95,15 @@ export declare class AgenticTools {
     private requireNonEmptyString;
     private requireArgsObject;
     private sessionApprovedTools;
+    private indexedCodebaseSearch;
     private static permissionsFile;
     constructor(logger: Logger, cwd: string, permissionCallback: (action: string, options?: {
         batchApproval?: boolean;
     }) => Promise<boolean | 'batch' | 'persist'>, autoApprove?: boolean);
+    /** Rebind tool execution to a different local workspace root (e.g. prompt path override). */
+    setWorkspaceRoot(cwd: string): void;
+    setIndexedCodebaseSearch(handler: ((query: string, maxResults: number) => string) | null): void;
+    getWorkspaceRoot(): string;
     private getErrorMessage;
     private assertToolCall;
     /**
@@ -183,6 +188,8 @@ export declare class AgenticTools {
      */
     private formatPermissionRequest;
     private sleep;
+    private bridgeToolsEnabled;
+    private tryBridgeReadFile;
     /**
      * Read file with enhanced error handling and suggestions
      */

package/dist/utils/tools.js

@@ -433,6 +433,7 @@ export class AgenticTools {
     }
     // Session-based tool approvals - remembers which tools user approved for this turn
     sessionApprovedTools = new Set();
+    indexedCodebaseSearch = null;
     // Persistent permissions - tool allowlists per project
     static permissionsFile = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.vigthoria', 'permissions.json');
     constructor(logger, cwd, permissionCallback, autoApprove = false) {
@@ -449,10 +450,23 @@ export class AgenticTools {
             throw new Error('AgenticTools initialization failed: autoApprove must be a boolean.');
         }
         this.logger = logger;
-        this.cwd = cwd;
+        this.cwd = path.resolve(cwd);
         this.permissionCallback = permissionCallback;
         this.autoApprove = autoApprove;
     }
+    /** Rebind tool execution to a different local workspace root (e.g. prompt path override). */
+    setWorkspaceRoot(cwd) {
+        if (typeof cwd !== 'string' || cwd.trim().length === 0) {
+            throw new Error('AgenticTools.setWorkspaceRoot failed: cwd must be a non-empty string.');
+        }
+        this.cwd = path.resolve(cwd);
+    }
+    setIndexedCodebaseSearch(handler) {
+        this.indexedCodebaseSearch = handler;
+    }
+    getWorkspaceRoot() {
+        return this.cwd;
+    }
     getErrorMessage(error) {
         if (error instanceof Error) {
             return error.message;
@@ -1234,10 +1248,52 @@ export class AgenticTools {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
     // Tool implementations with enhanced error handling and undo support
+    bridgeToolsEnabled() {
+        const flag = String(process.env.VIGTHORIA_BRIDGE_TOOLS || '').trim().toLowerCase();
+        return flag === '1' || flag === 'true' || flag === 'yes' || flag === 'on';
+    }
+    tryBridgeReadFile(args) {
+        if (!this.bridgeToolsEnabled()) {
+            return null;
+        }
+        const bridgeBase = String(process.env.VIGTHORIA_BRIDGE_HTTP
+            || process.env.VIGTHORIA_DESKTOP_BRIDGE_URL
+            || 'http://127.0.0.1:49160').replace(/\/$/, '');
+        const targetPath = args.path || '';
+        if (!targetPath) {
+            return null;
+        }
+        try {
+            const response = execSync(`curl -sS -m 15 -X POST "${bridgeBase}/tools/read_file" -H "Content-Type: application/json" -d ${JSON.stringify(JSON.stringify({
+                path: targetPath,
+                start_line: args.start_line ? Number(args.start_line) : undefined,
+                end_line: args.end_line ? Number(args.end_line) : undefined,
+            }))}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+            const payload = JSON.parse(response);
+            if (payload?.success === true) {
+                return {
+                    success: true,
+                    output: String(payload.output || payload.content || ''),
+                    metadata: { source: 'desktop-bridge', path: targetPath },
+                };
+            }
+            if (payload?.error) {
+                this.logger.debug(`Desktop bridge read failed for ${targetPath}: ${payload.error}`);
+            }
+        }
+        catch (error) {
+            this.logger.debug(`Desktop bridge read unavailable for ${targetPath}: ${this.formatExternalToolError('read_file', 'bridge delegation', error)}`);
+        }
+        return null;
+    }
     /**
      * Read file with enhanced error handling and suggestions
      */
     readFile(args) {
+        const bridgeRead = this.tryBridgeReadFile(args);
+        if (bridgeRead) {
+            return bridgeRead;
+        }
         const filePath = this.resolvePath(args.path);
         if (!fs.existsSync(filePath)) {
             // Try to find similar files
@@ -2763,6 +2819,16 @@ export class AgenticTools {
         const scope = args.scope || 'all';
         const includePattern = args.include || '';
         const maxResults = Math.min(parseInt(args.max_results || '30', 10), 100);
+        if (this.indexedCodebaseSearch && (scope === 'all' || scope === 'content')) {
+            const indexedOutput = this.indexedCodebaseSearch(query, maxResults);
+            if (indexedOutput && !indexedOutput.includes('No indexed codebase matches found')) {
+                return {
+                    success: true,
+                    output: indexedOutput,
+                    metadata: { searchStatus: 'search_matches_found', source: 'tfidf-index' },
+                };
+            }
+        }
         const results = [];
         const seen = new Set();
         // Helper: collect files recursively respecting gitignore-like patterns

package/dist/utils/workspace-brain-service.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Workspace Brain — local codebase index + Brain Hub sync for CLI.
+ */
+import { CodebaseIndexer, IndexMeta } from './codebase-indexer.js';
+export type WorkspaceBrainOptions = {
+    workspacePath: string;
+    apiBase?: string;
+    getAuthToken: () => string | null | Promise<string | null>;
+    autoIndex?: boolean;
+    brainSyncEnabled?: boolean;
+};
+export type EnsureIndexedResult = {
+    indexed: boolean;
+    fileCount: number;
+    chunkCount: number;
+    prompted?: 'index_now' | 'later' | 'skipped';
+};
+export declare class WorkspaceBrainService {
+    private workspacePath;
+    private indexer;
+    private brainClient;
+    private autoIndex;
+    private brainSyncEnabled;
+    private accountContextCache;
+    constructor(options: WorkspaceBrainOptions);
+    getIndexer(): CodebaseIndexer;
+    getStatus(): {
+        workspacePath: string;
+        indexedFileCount: number;
+        totalChunks: number;
+        isIndexing: boolean;
+        meta: IndexMeta | null;
+    };
+    ensureIndexed(options?: {
+        promptIfMissing?: boolean;
+        askToIndex?: (fileCount: number, workspaceName: string) => Promise<'index_now' | 'later'>;
+    }): Promise<EnsureIndexedResult>;
+    reindexWorkspace(): Promise<IndexMeta>;
+    buildCodebaseContext(prompt: string): string;
+    searchCodebase(query: string, maxResults?: number): string;
+    fetchAccountBrainContext(force?: boolean): Promise<string>;
+    private syncIndexToHub;
+}

package/dist/utils/workspace-brain-service.js

@@ -0,0 +1,121 @@
+/**
+ * Workspace Brain — local codebase index + Brain Hub sync for CLI.
+ */
+import * as path from 'path';
+import { BrainHubClient } from './brain-hub-client.js';
+import { CodebaseIndexer } from './codebase-indexer.js';
+export class WorkspaceBrainService {
+    workspacePath;
+    indexer;
+    brainClient;
+    autoIndex;
+    brainSyncEnabled;
+    accountContextCache = null;
+    constructor(options) {
+        this.workspacePath = path.resolve(options.workspacePath);
+        this.indexer = new CodebaseIndexer(this.workspacePath);
+        this.brainClient = new BrainHubClient({
+            apiBase: options.apiBase,
+            getAuthToken: options.getAuthToken,
+        });
+        this.autoIndex = options.autoIndex ?? !/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_AUTO_INDEX || ''));
+        this.brainSyncEnabled = options.brainSyncEnabled ?? !/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_BRAIN_SYNC || ''));
+    }
+    getIndexer() {
+        return this.indexer;
+    }
+    getStatus() {
+        const status = this.indexer.getStatus();
+        return {
+            workspacePath: this.workspacePath,
+            indexedFileCount: status.indexedFileCount,
+            totalChunks: status.totalChunks,
+            isIndexing: status.isIndexing,
+            meta: CodebaseIndexer.loadMeta(this.workspacePath),
+        };
+    }
+    async ensureIndexed(options = {}) {
+        if (this.indexer.hasLocalIndex() && this.indexer.getStatus().totalChunks === 0) {
+            const meta = await this.indexer.indexWorkspace();
+            await this.syncIndexToHub(meta);
+            return { indexed: true, fileCount: meta.indexedFileCount, chunkCount: meta.totalChunks };
+        }
+        if (this.indexer.hasLocalIndex()) {
+            const meta = CodebaseIndexer.loadMeta(this.workspacePath);
+            return {
+                indexed: true,
+                fileCount: meta?.indexedFileCount || this.indexer.getStatus().indexedFileCount,
+                chunkCount: meta?.totalChunks || this.indexer.getStatus().totalChunks,
+            };
+        }
+        if (!this.autoIndex && !options.promptIfMissing) {
+            return { indexed: false, fileCount: 0, chunkCount: 0, prompted: 'skipped' };
+        }
+        if (options.promptIfMissing && options.askToIndex) {
+            const wsName = path.basename(this.workspacePath);
+            const fileCount = this.indexer.countIndexableFiles();
+            if (fileCount === 0) {
+                return { indexed: false, fileCount: 0, chunkCount: 0, prompted: 'skipped' };
+            }
+            const choice = await options.askToIndex(fileCount, wsName);
+            if (choice === 'later') {
+                return { indexed: false, fileCount: 0, chunkCount: 0, prompted: 'later' };
+            }
+        }
+        const meta = await this.indexer.indexWorkspace();
+        await this.syncIndexToHub(meta);
+        return {
+            indexed: true,
+            fileCount: meta.indexedFileCount,
+            chunkCount: meta.totalChunks,
+            prompted: options.promptIfMissing ? 'index_now' : undefined,
+        };
+    }
+    async reindexWorkspace() {
+        const meta = await this.indexer.indexWorkspace();
+        await this.syncIndexToHub(meta);
+        return meta;
+    }
+    buildCodebaseContext(prompt) {
+        if (!prompt.trim() || !this.indexer.hasLocalIndex()) {
+            return '';
+        }
+        const context = this.indexer.getContextForQuery(prompt, 3500);
+        if (!context) {
+            return '';
+        }
+        return `Vigthoria codebase index context.\n${context}`;
+    }
+    searchCodebase(query, maxResults = 30) {
+        return this.indexer.formatSearchResults(query, maxResults);
+    }
+    async fetchAccountBrainContext(force = false) {
+        if (!this.brainSyncEnabled) {
+            return '';
+        }
+        const cacheTtlMs = 5 * 60 * 1000;
+        if (!force && this.accountContextCache && Date.now() - this.accountContextCache.fetchedAt < cacheTtlMs) {
+            return this.accountContextCache.text;
+        }
+        const response = await this.brainClient.fetchAccountContext(25);
+        const text = String(response.formattedText || '').trim();
+        this.accountContextCache = { text, fetchedAt: Date.now() };
+        return text;
+    }
+    async syncIndexToHub(meta) {
+        if (!this.brainSyncEnabled) {
+            return;
+        }
+        const wsName = path.basename(this.workspacePath);
+        const summary = `Workspace "${wsName}" indexed in Vigthoria CLI: ${meta.indexedFileCount} files, ${meta.totalChunks} chunks. Key paths: ${meta.topFiles.slice(0, 6).join(', ')}`;
+        await this.brainClient.syncWorkspaceIndex({
+            workspaceName: wsName,
+            workspacePath: this.workspacePath,
+            fileCount: meta.indexedFileCount,
+            chunkCount: meta.totalChunks,
+            topFiles: meta.topFiles,
+            summary,
+            indexHash: meta.indexHash,
+        }).catch(() => undefined);
+    }
+}

package/dist/utils/workspace-stream.js

@@ -37,6 +37,17 @@ const IGNORE_PATTERNS = [
     '**/.vigthoria/**',
     '**/coverage/**',
     '**/*.pyc',
+    // CRITICAL: Windows AppData & system directories (prevents EPERM errors)
+    '**/Anwendungsdaten/**', // German AppData
+    '**/AppData/**', // English AppData
+    '**/Local Settings/**', // Legacy Windows
+    '**/Application Data/**', // Legacy Windows
+    '**/$RECYCLE.BIN/**', // Windows Recycle Bin
+    '**/System Volume Information/**',
+    '**/Temp/**',
+    '**/tmp/**',
+    '**/OneDrive/**', // OneDrive cache
+    '**/MicrosoftEdgeBackups/**',
 ];
 const BINARY_EXTENSIONS = new Set([
     '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp', '.bmp',
@@ -103,24 +114,54 @@ export class WorkspaceWatcher {
     start() {
         if (this.watcher)
             return;
-        this.watcher = chokidar.watch(this.workspaceRoot, {
-            ignored: IGNORE_PATTERNS,
-            persistent: true,
-            ignoreInitial: true,
-            awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
-        });
-        this.watcher
-            .on('ready', () => {
-            this._ready = true;
-            logger.debug('Workspace watcher ready');
-        })
-            .on('add', (filePath) => this._handleChange(filePath, 'write'))
-            .on('change', (filePath) => this._handleChange(filePath, 'write'))
-            .on('unlink', (filePath) => this._handleChange(filePath, 'delete'));
+        try {
+            this.watcher = chokidar.watch(this.workspaceRoot, {
+                ignored: IGNORE_PATTERNS,
+                persistent: false,
+                ignoreInitial: true,
+                awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
+                // Windows-specific settings to prevent EPERM on system directories
+                usePolling: false,
+                interval: 100,
+                binaryInterval: 300,
+                depth: 50, // Limit traversal depth
+            });
+            this.watcher
+                .on('ready', () => {
+                this._ready = true;
+                logger.debug('Workspace watcher ready');
+            })
+                .on('add', (filePath) => this._handleChange(filePath, 'write'))
+                .on('change', (filePath) => this._handleChange(filePath, 'write'))
+                .on('unlink', (filePath) => this._handleChange(filePath, 'delete'))
+                // CRITICAL: Handle permission errors gracefully (Windows AppData EPERM)
+                .on('error', (error) => {
+                if (error?.code === 'EPERM' || error?.errno === -4048) {
+                    logger.warn(`Workspace watcher permission error (ignored): ${error.message}`);
+                    // Continue without watcher; don't crash
+                }
+                else {
+                    logger.error(`Workspace watcher error: ${error?.message || error}`);
+                }
+            });
+        }
+        catch (err) {
+            // Handle initialization errors (e.g., EPERM during chokidar.watch setup)
+            if (err?.code === 'EPERM' || err?.errno === -4048 || err?.message?.includes('EPERM')) {
+                logger.warn(`Failed to initialize workspace watcher (EPERM): ${err.message}`);
+                logger.info('Continuing without file watcher; local file changes will not sync in real-time');
+                this.watcher = null;
+            }
+            else {
+                logger.error(`Failed to initialize workspace watcher: ${err.message}`);
+                throw err;
+            }
+        }
     }
     stop() {
         if (this.watcher) {
-            this.watcher.close();
+            // close() returns a Promise; fire-and-forget so handles are released
+            this.watcher.close().catch(() => { });
             this.watcher = null;
             this._ready = false;
         }

package/install.ps1

@@ -5,7 +5,7 @@
 $ErrorActionPreference = "Stop"
 
 # Configuration
-$CLI_VERSION = "1.9.22"
+$CLI_VERSION = "1.10.18"
 $INSTALL_DIR = "$env:USERPROFILE\.vigthoria"
 $NPM_PACKAGE = "vigthoria-cli"
 $GIT_PACKAGE_URL = "git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"

package/install.sh

@@ -26,7 +26,7 @@ else
 fi
 
 # Configuration
-CLI_VERSION="1.9.22"
+CLI_VERSION="1.10.18"
 INSTALL_DIR="$HOME/.vigthoria"
 REPO_URL="https://market.vigthoria.io/vigthoria/vigthoria-cli"
 GIT_PACKAGE_URL="git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.10.1",
+  "version": "1.10.37",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -65,7 +65,9 @@
     "test:model:governance": "npm run build && node scripts/test-model-governance-no-agent.js",
     "validate:no-go": "bash scripts/release/validate-no-go-gates.sh",
     "test:legion:billing:e2e": "npm run build && node scripts/test-legion-godmode-billing-e2e.js",
-    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js"
+    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js",
+    "test:persona": "npm run build && node scripts/test-persona-mode.mjs",
+    "test:error-wording": "npm run build && node scripts/test-error-wording.mjs"
   },
   "keywords": [
     "ai",

package/scripts/release/validate-no-go-gates.sh

@@ -46,7 +46,7 @@ import('./dist/utils/context-ranker.js').then((m)=>{
 EOF2
 
 echo "[2.1/2.4] tsc validator emits passing result"
-node - << 'EOF2'
+node --input-type=module - << 'EOF2'
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';