Removes outdated prompt files

Removes the `Chat Prompt.txt`, `VSCode Agent/Prompt.txt`, `Warp.dev/Prompt.txt`, and `v0 Prompts and Tools/Prompt.txt` files.

These files likely contain outdated prompts or configurations that are no longer needed in the current project. Removing them helps to clean up the codebase and prevent potential confusion or conflicts.
This commit is contained in:
dopeuni444
2025-07-31 01:45:01 +04:00
parent 23a65fbb9e
commit d43632a49a
91 changed files with 27187 additions and 1648 deletions

View File

@@ -0,0 +1,218 @@
import { Logger } from '../utils/logger';
import { MemoryManager } from '../memory/memory-manager';
import { ToolExecutor } from '../tools/tool-executor';
import { VoiceProcessor } from '../voice/voice-processor';
export interface AIResponse {
success: boolean;
message: string;
data?: any;
error?: string;
memory?: any;
autopilot?: boolean;
}
export interface CommandRequest {
command: string;
userId?: string;
context?: any;
voice?: boolean;
autopilot?: boolean;
}
export class NowhereCore {
private logger: Logger;
private memory: MemoryManager;
private tools: ToolExecutor;
private voice: VoiceProcessor;
private isAutopilotEnabled: boolean = false;
constructor() {
this.logger = new Logger('NowhereCore');
this.memory = new MemoryManager();
this.tools = new ToolExecutor();
this.voice = new VoiceProcessor();
}
/**
* Process a command from the user
*/
async processCommand(request: CommandRequest): Promise<AIResponse> {
try {
this.logger.info('Processing command', { command: request.command, userId: request.userId });
// Load user context and memory
const userContext = await this.memory.getUserContext(request.userId);
// Parse and understand the command
const parsedCommand = await this.parseCommand(request.command, userContext);
// Execute the command
const result = await this.executeCommand(parsedCommand, request);
// Update memory with the interaction
await this.memory.updateUserContext(request.userId, {
lastCommand: request.command,
lastResult: result,
timestamp: new Date().toISOString()
});
return {
success: true,
message: result.message,
data: result.data,
memory: userContext
};
} catch (error) {
this.logger.error('Error processing command', { error: error.message });
return {
success: false,
message: 'Failed to process command',
error: error.message
};
}
}
/**
* Parse and understand the user's command
*/
private async parseCommand(command: string, context: any): Promise<any> {
// This would integrate with OpenAI/Anthropic for natural language understanding
const intent = await this.analyzeIntent(command);
const entities = await this.extractEntities(command);
return {
original: command,
intent,
entities,
context
};
}
/**
* Execute the parsed command
*/
private async executeCommand(parsed: any, request: CommandRequest): Promise<any> {
const { intent, entities } = parsed;
switch (intent.type) {
case 'file_operation':
return await this.tools.executeFileOperation(entities);
case 'terminal_command':
return await this.tools.executeTerminalCommand(entities.command);
case 'code_analysis':
return await this.tools.analyzeCode(entities.file);
case 'web_search':
return await this.tools.searchWeb(entities.query);
case 'autopilot_toggle':
this.isAutopilotEnabled = !this.isAutopilotEnabled;
return {
message: `Autopilot mode ${this.isAutopilotEnabled ? 'enabled' : 'disabled'}`,
data: { autopilot: this.isAutopilotEnabled }
};
case 'voice_command':
return await this.voice.processVoiceCommand(entities);
case 'memory_query':
return await this.memory.queryMemory(entities.query);
default:
return {
message: `I understand you want to ${intent.type}. Let me help you with that.`,
data: { intent, entities }
};
}
}
/**
* Analyze the intent of a command using AI
*/
private async analyzeIntent(command: string): Promise<any> {
// Mock AI analysis - in real implementation, this would call OpenAI/Anthropic
const intents = {
'file': 'file_operation',
'read': 'file_operation',
'write': 'file_operation',
'create': 'file_operation',
'delete': 'file_operation',
'run': 'terminal_command',
'execute': 'terminal_command',
'analyze': 'code_analysis',
'search': 'web_search',
'find': 'web_search',
'autopilot': 'autopilot_toggle',
'voice': 'voice_command',
'remember': 'memory_query',
'recall': 'memory_query'
};
const words = command.toLowerCase().split(' ');
for (const word of words) {
if (intents[word]) {
return { type: intents[word], confidence: 0.9 };
}
}
return { type: 'general', confidence: 0.5 };
}
/**
* Extract entities from the command
*/
private async extractEntities(command: string): Promise<any> {
// Mock entity extraction - in real implementation, this would use NLP
const entities: any = {};
// Extract file paths
const fileMatch = command.match(/(\w+\.\w+)/);
if (fileMatch) {
entities.file = fileMatch[1];
}
// Extract commands
const commandMatch = command.match(/run\s+(.+)/i);
if (commandMatch) {
entities.command = commandMatch[1];
}
// Extract search queries
const searchMatch = command.match(/search\s+(.+)/i);
if (searchMatch) {
entities.query = searchMatch[1];
}
return entities;
}
/**
* Enable or disable autopilot mode
*/
async toggleAutopilot(enabled: boolean): Promise<AIResponse> {
this.isAutopilotEnabled = enabled;
this.logger.info('Autopilot mode toggled', { enabled });
return {
success: true,
message: `Autopilot mode ${enabled ? 'enabled' : 'disabled'}`,
data: { autopilot: enabled }
};
}
/**
* Get current system status
*/
async getStatus(): Promise<any> {
return {
autopilot: this.isAutopilotEnabled,
memory: await this.memory.getStats(),
tools: await this.tools.getStatus(),
voice: await this.voice.getStatus()
};
}
}