vigthoria-cli 1.4.1 → 1.4.3

package/src/commands/chat.ts

@@ -44,7 +44,8 @@ export class ChatCommand {
     this.config = config;
     this.logger = logger;
     this.api = new APIClient(config, logger);
-    this.fileUtils = new FileUtils(process.cwd(), config.get('project').ignorePatterns);
+    // Initialize with a safe default - will be updated in run()
+    this.fileUtils = new FileUtils('.', config.get('project').ignorePatterns);
     this.sessionManager = new SessionManager();
     
     // Setup marked for terminal rendering
@@ -53,6 +54,17 @@ export class ChatCommand {
   }
 
   async run(options: ChatOptions): Promise<void> {
+    // Resolve and validate project path
+    const projectPath = this.resolveProjectPath(options.project);
+    if (!projectPath) {
+      this.logger.error(`Project path not found: ${options.project}`);
+      this.logger.info('Please specify a valid project directory with -p <path>');
+      return;
+    }
+    
+    // Update fileUtils with correct project path
+    this.fileUtils = new FileUtils(projectPath, this.config.get('project').ignorePatterns);
+    
     // STRICT AUTHENTICATION - No local bypass
     if (!this.config.isAuthenticated()) {
       this.logger.error('');
@@ -91,7 +103,7 @@ export class ChatCommand {
       }
     }
 
-    // Setup agentic tools if enabled
+    // Setup agentic tools if enabled - use resolved project path
     this.agentMode = options.agent || false;
     this.streamMode = options.stream !== false; // Default to true
     this.localMode = false; // Never use local mode - always use Vigthoria API
@@ -99,7 +111,7 @@ export class ChatCommand {
     if (this.agentMode) {
       this.tools = new AgenticTools(
         this.logger,
-        options.project,
+        projectPath,  // Use resolved path
         this.askPermission.bind(this),
         options.autoApprove || false
       );
@@ -107,7 +119,7 @@ export class ChatCommand {
 
     // Try to resume previous session or create new one
     if (options.resume) {
-      this.currentSession = this.sessionManager.getLatest(options.project);
+      this.currentSession = this.sessionManager.getLatest(projectPath);
       if (this.currentSession) {
         this.messages = [...this.currentSession.messages];
         this.logger.success(`Resumed session: ${this.currentSession.id}`);
@@ -116,33 +128,44 @@ export class ChatCommand {
 
     if (!this.currentSession) {
       this.currentSession = this.sessionManager.create(
-        options.project,
+        projectPath,  // Use resolved path
         options.model,
         this.agentMode
       );
     }
 
-    // Get project context
-    const projectContext = await this.fileUtils.getProjectContext();
+    // Get project context with error handling
+    let projectContext = { type: 'unknown', files: [] as string[], dependencies: {} as Record<string, string> };
+    try {
+      projectContext = await this.fileUtils.getProjectContext();
+    } catch (error) {
+      // Continue without project context if it fails
+      this.logger.warn('Could not read project context, continuing without it.');
+    }
     
     // Setup system message
     const systemMessage: ChatMessage = {
       role: 'system',
-      content: this.buildSystemPrompt(projectContext, options),
+      content: this.buildSystemPrompt(projectContext, { ...options, project: projectPath }),
     };
     this.messages.push(systemMessage);
 
-    this.printWelcome(options);
+    this.printWelcome({ ...options, project: projectPath });
     
     // Start REPL
-    await this.startRepl(options);
+    await this.startRepl({ ...options, project: projectPath });
   }
 
   private buildSystemPrompt(
     projectContext: { type: string; files: string[]; dependencies: Record<string, string> },
     options: ChatOptions
   ): string {
-    let prompt = `You are Vigthoria, a premium AI coding assistant. You help developers write, understand, and improve code.
+    let prompt = `You are Vigthoria, the premier AI coding assistant of Vigthoria Technologies.
+
+IDENTITY:
+- Created by Vigthoria Technologies
+- Mascot: Viggy the Blue Queen
+- Philosophy: "Innovation through Intelligence"
 
 Project Context:
 - Type: ${projectContext.type}
@@ -150,12 +173,22 @@ Project Context:
 - Key files: ${projectContext.files.slice(0, 10).join(', ')}
 ${projectContext.type === 'node' ? `- Dependencies: ${Object.keys(projectContext.dependencies).slice(0, 15).join(', ')}` : ''}
 
+CODE QUALITY STANDARDS (CRITICAL):
+1. ALWAYS produce complete, production-ready code - no placeholders
+2. When creating UI/HTML/CSS:
+   - Ensure proper color contrast (text readable against backgrounds)
+   - Use CSS variables for theming
+   - Include responsive design
+3. Include proper error handling
+4. Add meaningful comments for complex logic
+5. Follow modern best practices (2024-2026 standards)
+6. Use semantic HTML, accessible patterns
+7. Show COMPLETE implementations
+
 Guidelines:
-- Provide complete, production-ready code
-- Use modern best practices (2024-2026 standards)
-- Include proper error handling
-- Explain your reasoning when helpful
+- Provide working code first, explanations second
 - Be concise but thorough
+- Excellence is the standard - mediocrity is not acceptable
 
 Special Commands (user may use these):
 - /file <path> - Read and include a file in context
@@ -164,7 +197,7 @@ Special Commands (user may use these):
 - /apply - Apply pending changes
 - /clear - Clear conversation history
 - /model <name> - Switch AI model
-- /agent - Toggle agentic mode (Vigthoria Autonomous autonomous actions)
+- /agent - Toggle agentic mode (Vigthoria autonomous actions)
 - /help - Show available commands`;
 
     // Add tool instructions if in agent mode
@@ -175,6 +208,49 @@ Special Commands (user may use these):
     return prompt;
   }
 
+  /**
+   * Resolve and validate project path - handles Windows paths properly
+   */
+  private resolveProjectPath(inputPath: string): string | null {
+    const path = require('path');
+    const fs = require('fs');
+    
+    try {
+      // Resolve to absolute path
+      let resolvedPath = inputPath;
+      
+      if (!path.isAbsolute(inputPath)) {
+        resolvedPath = path.resolve(process.cwd(), inputPath);
+      }
+      
+      // Normalize the path for the current OS
+      resolvedPath = path.normalize(resolvedPath);
+      
+      // Check if path exists
+      if (fs.existsSync(resolvedPath)) {
+        const stats = fs.statSync(resolvedPath);
+        if (stats.isDirectory()) {
+          return resolvedPath;
+        }
+      }
+      
+      // Try current working directory as fallback
+      const cwd = process.cwd();
+      if (fs.existsSync(cwd)) {
+        return cwd;
+      }
+      
+      return null;
+    } catch (error) {
+      // Return current directory on any error
+      try {
+        return process.cwd();
+      } catch {
+        return null;
+      }
+    }
+  }
+
   private printWelcome(options: ChatOptions): void {
     const sub = this.config.get('subscription');
     

package/src/index.ts

@@ -51,7 +51,7 @@ function getVersion(): string {
   } catch (e) {
     // Fallback to hardcoded version
   }
-  return '1.4.0';
+  return '1.4.1';
 }
 const VERSION = getVersion();
 

package/src/utils/files.ts

@@ -19,17 +19,36 @@ export class FileUtils {
   private ignorePatterns: string[];
 
   constructor(projectRoot: string, ignorePatterns: string[] = []) {
-    this.projectRoot = projectRoot;
+    // Resolve symlinks and normalize path for consistent behavior
+    try {
+      this.projectRoot = fs.realpathSync(projectRoot);
+    } catch {
+      // If realpath fails (e.g., path doesn't exist), use the original
+      this.projectRoot = path.resolve(projectRoot);
+    }
     this.ignorePatterns = ignorePatterns;
   }
 
   // Read file with metadata
   readFile(filePath: string): FileInfo | null {
     try {
-      const absolutePath = path.isAbsolute(filePath) 
+      let absolutePath = path.isAbsolute(filePath) 
         ? filePath 
         : path.join(this.projectRoot, filePath);
       
+      // Resolve symlinks for consistent path handling
+      try {
+        absolutePath = fs.realpathSync(absolutePath);
+      } catch {
+        // Keep original path if realpath fails
+      }
+      
+      // Check if it's a regular file (not a directory or special file)
+      const stats = fs.statSync(absolutePath);
+      if (!stats.isFile()) {
+        return null;
+      }
+      
       const content = fs.readFileSync(absolutePath, 'utf-8');
       const relativePath = path.relative(this.projectRoot, absolutePath);
       
@@ -88,13 +107,23 @@ export class FileUtils {
 
   // List project files
   async listFiles(pattern: string = '**/*'): Promise<string[]> {
-    const files = await glob(pattern, {
-      cwd: this.projectRoot,
-      ignore: this.ignorePatterns,
-      nodir: true,
-    });
+    try {
+      // Check if project root exists
+      if (!fs.existsSync(this.projectRoot)) {
+        return [];
+      }
+      
+      const files = await glob(pattern, {
+        cwd: this.projectRoot,
+        ignore: this.ignorePatterns,
+        nodir: true,
+      });
 
-    return files;
+      return files;
+    } catch (error) {
+      // Return empty array on error (e.g., permission issues on Windows)
+      return [];
+    }
   }
 
   // Detect language from file extension

package/src/utils/session.ts

@@ -28,8 +28,20 @@ export class SessionManager {
   }
 
   private ensureDir(): void {
-    if (!fs.existsSync(this.sessionsDir)) {
-      fs.mkdirSync(this.sessionsDir, { recursive: true });
+    try {
+      if (!fs.existsSync(this.sessionsDir)) {
+        fs.mkdirSync(this.sessionsDir, { recursive: true, mode: 0o755 });
+      }
+    } catch (error: any) {
+      // On permission errors, try alternative location
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        // Fallback to temp directory
+        this.sessionsDir = path.join(os.tmpdir(), 'vigthoria-sessions');
+        if (!fs.existsSync(this.sessionsDir)) {
+          fs.mkdirSync(this.sessionsDir, { recursive: true });
+        }
+      }
+      // Silently continue if directory creation fails
     }
   }
 

package/src/utils/tools.ts

@@ -771,13 +771,34 @@ export class AgenticTools {
     
     try {
       const startTime = Date.now();
-      const output = execSync(args.command, {
+      const os = require('os');
+      const platform = os.platform();
+      
+      // Build exec options based on platform
+      const execOptions: any = {
         cwd,
         timeout,
         encoding: 'utf-8',
         maxBuffer: 10 * 1024 * 1024, // 10MB
         stdio: ['pipe', 'pipe', 'pipe'],
-      });
+        // Ensure consistent environment
+        env: {
+          ...process.env,
+          // Prevent locale issues
+          LC_ALL: 'C',
+          LANG: 'C',
+        },
+      };
+      
+      // Set shell based on platform for consistent behavior
+      if (platform === 'win32') {
+        execOptions.shell = true; // Use default cmd.exe on Windows
+      } else {
+        // Use /bin/sh on Unix-like systems (more portable than bash)
+        execOptions.shell = '/bin/sh';
+      }
+      
+      const output = execSync(args.command, execOptions) as string;
       
       const duration = Date.now() - startTime;
       
@@ -833,10 +854,27 @@ export class AgenticTools {
   private grep(args: Record<string, string>): ToolResult {
     const searchPath = args.path ? this.resolvePath(args.path) : this.cwd;
     const include = args.include || '*';
+    const os = require('os');
+    
+    // macOS uses BSD grep which has different options than GNU grep
+    const isMac = os.platform() === 'darwin';
     
-    let cmd = `grep -rn --color=never "${args.pattern}" ${searchPath}`;
-    if (args.include) {
-      cmd = `grep -rn --color=never --include="${args.include}" "${args.pattern}" ${searchPath}`;
+    let cmd: string;
+    if (isMac) {
+      // BSD grep: use -r for recursive, -n for line numbers
+      // Note: BSD grep doesn't support --color=never, just omit it
+      if (args.include) {
+        cmd = `grep -rn --include="${args.include}" "${args.pattern}" "${searchPath}"`;
+      } else {
+        cmd = `grep -rn "${args.pattern}" "${searchPath}"`;
+      }
+    } else {
+      // GNU grep (Linux)
+      if (args.include) {
+        cmd = `grep -rn --color=never --include="${args.include}" "${args.pattern}" "${searchPath}"`;
+      } else {
+        cmd = `grep -rn --color=never "${args.pattern}" "${searchPath}"`;
+      }
     }
     
     try {
@@ -845,6 +883,7 @@ export class AgenticTools {
         encoding: 'utf-8',
         maxBuffer: 5 * 1024 * 1024,
         timeout: 30000,
+        env: { ...process.env, GREP_OPTIONS: '' }, // Prevent user's grep options from interfering
       });
       
       return { success: true, output: output.trim() };