#!/usr/bin/env node

import inquirer from "inquirer";

import axios from "axios";

import fs from "fs";

import path from "path";

import { spawn } from "child_process";

import os from "os";

// Configuration storage path

const CONFIG_DIR = path.join(os.homedir(), ".ai-file-assistant");

const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");

// Color definitions for beautiful UI

const colors = {

primary: "\x1b[36m", // Cyan

secondary: "\x1b[35m", // Magenta

success: "\x1b[32m", // Green

warning: "\x1b[33m", // Yellow

error: "\x1b[31m", // Red

info: "\x1b[34m", // Blue

highlight: "\x1b[95m", // Bright Magenta

reset: "\x1b[0m", // Reset

bold: "\x1b[1m", // Bold

dim: "\x1b[2m", // Dim

};

const PROVIDERS = {

ollama: {

name: "Ollama",

apiUrl: "http://localhost:11434/api/chat",

streamUrl: "http://localhost:11434/api/chat",

models: [

"llama3.2:3b",

"llama3.1:8b",

"codellama:7b",

"qwen2.5-coder:7b",

"custom",

],

defaultModel: "qwen2.5-coder:7b",

requiresApiKey: false,

color: colors.info,

},

mistral: {

name: "Mistral",

apiUrl: "https://api.mistral.ai/v1/chat/completions",

streamUrl: "https://api.mistral.ai/v1/chat/completions",

models: [

"mistral-tiny",

"mistral-small",

"mistral-medium",

"mistral-large-latest",

"codestral-latest",

"custom",

],

defaultModel: "mistral-small",

requiresApiKey: true,

apiKey: null,

color: colors.primary,

},

openai: {

name: "OpenAI",

apiUrl: "https://api.openai.com/v1/chat/completions",

streamUrl: "https://api.openai.com/v1/chat/completions",

models: [

"gpt-4",

"gpt-4-turbo",

"gpt-3.5-turbo",

"gpt-4o",

"o1-preview",

"custom",

],

defaultModel: "gpt-4o",

requiresApiKey: true,

apiKey: null,

color: colors.success,

},

claude: {

name: "Claude",

apiUrl: "https://api.anthropic.com/v1/messages",

streamUrl: "https://api.anthropic.com/v1/messages",

models: [

"claude-3-5-sonnet-20241022",

"claude-3-opus-20240229",

"claude-3-haiku-20240307",

"custom",

],

defaultModel: "claude-3-5-sonnet-20241022",

requiresApiKey: true,

apiKey: null,

color: colors.highlight,

},

google: {

name: "Google Gemini",

apiUrl: "https://generativelanguage.googleapis.com/v1beta/models",

streamUrl: "https://generativelanguage.googleapis.com/v1beta/models",

models: ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro", "custom"],

defaultModel: "gemini-1.5-pro",

requiresApiKey: true,

apiKey: null,

color: colors.warning,

},

};

// Memory Buffer System - Simplified

class MemoryBuffer {

constructor() {

this.files = new Map(); // Store file contents

this.actions = []; // Store recent actions

this.conversations = []; // Store conversation history

}

storeFile(filePath, content) {

this.files.set(filePath, {

content,

lastModified: new Date().toISOString(),

size: content.length,

});

console.log(

colors.success +

"📄 " +

path.basename(filePath) +

" stored" +

colors.reset

);

}

getFile(filePath) {

return this.files.get(filePath);

}

listFiles() {

return Array.from(this.files.keys());

}

addAction(action, target, result) {

this.actions.push({

action,

target,

result,

timestamp: new Date().toISOString(),

});

// Keep only last 50 actions

if (this.actions.length > 50) {

this.actions = this.actions.slice(-50);

}

}

getContext() {

const recentActions = this.actions.slice(-5);

const availableFiles = Array.from(this.files.keys());

return {

recentActions,

availableFiles,

totalFiles: this.files.size,

// Add more detailed file info for the AI

fileDetails: Array.from(this.files.entries()).map(([filePath, info]) => ({

path: filePath,

name: path.basename(filePath),

size: info.size,

lastModified: info.lastModified,

})),

};

}

}

// Configuration Management

function loadConfig() {

try {

if (!fs.existsSync(CONFIG_DIR)) {

fs.mkdirSync(CONFIG_DIR, { recursive: true });

}

if (fs.existsSync(CONFIG_FILE)) {

const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));

// Load saved API keys and models into PROVIDERS

for (const [providerKey, providerConfig] of Object.entries(

config.providers || {}

)) {

if (PROVIDERS[providerKey]) {

PROVIDERS[providerKey].apiKey = providerConfig.apiKey;

PROVIDERS[providerKey].selectedModel =

providerConfig.selectedModel || PROVIDERS[providerKey].defaultModel;

}

}

return config;

}

} catch (error) {

console.log(

colors.warning +

"Warning: Could not load config: " +

error.message +

colors.reset

);

}

return { providers: {}, preferences: {} };

}

function saveConfig(config) {

try {

if (!fs.existsSync(CONFIG_DIR)) {

fs.mkdirSync(CONFIG_DIR, { recursive: true });

}

fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));

console.log(

colors.success + "Configuration saved successfully" + colors.reset

);

} catch (error) {

console.log(

colors.error + "Could not save config: " + error.message + colors.reset

);

}

}

function updateProviderConfig(provider, apiKey, model) {

const config = loadConfig();

if (!config.providers) config.providers = {};

config.providers[provider] = {

apiKey: apiKey,

selectedModel: model,

};

saveConfig(config);

PROVIDERS[provider].apiKey = apiKey;

PROVIDERS[provider].selectedModel = model;

}

// Special Tokens for Unvibe Commands

const UNVIBE_TOKENS = {

READ: "<|unvibe_read|>",

DELETE: "<|unvibe_delete|>",

EDIT: "<|unvibe_edit|>",

CREATE_FILE: "<|unvibe_create_file|>",

CREATE_FOLDER: "<|unvibe_create_folder|>",

RENAME: "<|unvibe_rename|>",

TERMINAL: "<|unvibe_terminal|>",

LIST: "<|unvibe_list|>",

SEARCH: "<|unvibe_search|>",

END: "<|unvibe_end|>",

SEPARATOR: "<|parameter_separator|>",

};

// Parse special tokens from AI response

function parseUnvibeTokens(text) {

const commands = [];

// Only parse if we have potential complete tokens

if (!text.includes("<|unvibe_") || !text.includes("<|/unvibe_")) {

return commands;

}

// Look for complete token patterns: <|token|>content<|parameter_separator|>target<|/token|>

const tokenPattern =

/<\|unvibe_(\w+)\|>([\s\S]*?)<\|parameter_separator\|>([\s\S]*?)<\|\/unvibe_\1\|>/g;

let match;

while ((match = tokenPattern.exec(text)) !== null) {

const action = match[1];

const parameter = match[2].trim();

const target = match[3].trim();

commands.push({

action,

parameter,

target,

fullMatch: match[0],

});

}

if (commands.length > 0) {

console.log(

colors.info +

"Found " +

commands.length +

" complete token(s)" +

colors.reset

);

// Debug: show what tokens were found

commands.forEach((cmd, index) => {

console.log(

colors.dim +

`Token ${index + 1}: ${cmd.action} -> ${cmd.target}` +

colors.reset

);

});

}

return commands;

}

// Execute Unvibe commands

async function executeUnvibeCommand(command, memory) {

const { action, parameter, target } = command;

console.log(

colors.info +

"Executing: " +

action.toUpperCase() +

" " +

(action === "terminal" ? parameter : target) +

colors.reset

);

try {

switch (action) {

case "read":

return await executeRead(target, memory);

case "delete":

return await executeDelete(target, memory);

case "edit":

return await executeEdit(target, parameter, memory);

case "create_file":

return await executeCreateFile(target, parameter, memory);

case "create_folder":

return await executeCreateFolder(target, memory);

case "rename":

return await executeRename(parameter, target, memory);

case "terminal":

// For terminal commands, parameter is the command, target is the description

return await executeTerminal(parameter, memory);

case "list":

return await executeList(target, memory);

case "search":

return await executeSearch(parameter, target, memory);

default:

return { success: false, message: "Unknown action: " + action };

}

} catch (error) {

console.log(

colors.error +

"Error executing " +

action +

": " +

error.message +

colors.reset

);

return { success: false, message: error.message };

}

}

// Command implementations

async function executeRead(filePath, memory) {

try {

// Try to resolve file path

const resolvedPath = resolveFilePath(filePath);

if (!fs.existsSync(resolvedPath)) {

return { success: false, message: "File not found: " + filePath };

}

const content = fs.readFileSync(resolvedPath, "utf-8");

memory.storeFile(resolvedPath, content);

memory.addAction("read", filePath, { success: true });

console.log(

colors.success +

"📄 " +

path.basename(resolvedPath) +

" read (" +

content.length +

" chars)" +

colors.reset

);

return {

success: true,

message: "File read successfully",

content,

path: resolvedPath,

};

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeDelete(filePath, memory) {

try {

const resolvedPath = resolveFilePath(filePath);

if (!fs.existsSync(resolvedPath)) {

return { success: false, message: "File not found: " + filePath };

}

const stats = fs.statSync(resolvedPath);

if (stats.isDirectory()) {

fs.rmSync(resolvedPath, { recursive: true, force: true });

} else {

fs.unlinkSync(resolvedPath);

}

memory.addAction("delete", filePath, { success: true });

console.log(

colors.success +

"🗑️ " +

path.basename(resolvedPath) +

" deleted" +

colors.reset

);

return { success: true, message: "Deleted successfully" };

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeEdit(filePath, newContent, memory) {

try {

const resolvedPath = resolveFilePath(filePath);

// Create directories if they don't exist

const dir = path.dirname(resolvedPath);

if (!fs.existsSync(dir)) {

fs.mkdirSync(dir, { recursive: true });

}

fs.writeFileSync(resolvedPath, newContent, "utf-8");

memory.storeFile(resolvedPath, newContent);

memory.addAction("edit", filePath, { success: true });

console.log(

colors.success +

"✏️ " +

path.basename(resolvedPath) +

" edited (" +

newContent.length +

" chars)" +

colors.reset

);

return { success: true, message: "File edited successfully" };

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeCreateFile(filePath, content, memory) {

try {

const resolvedPath = resolveFilePath(filePath);

// Create directories if they don't exist

const dir = path.dirname(resolvedPath);

if (!fs.existsSync(dir)) {

fs.mkdirSync(dir, { recursive: true });

}

fs.writeFileSync(resolvedPath, content, "utf-8");

memory.storeFile(resolvedPath, content);

memory.addAction("create_file", filePath, { success: true });

console.log(

colors.success +

"📝 " +

path.basename(resolvedPath) +

" created (" +

content.length +

" chars)" +

colors.reset

);

return { success: true, message: "File created successfully" };

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeCreateFolder(folderPath, memory) {

try {

const resolvedPath = resolveFilePath(folderPath);

if (!fs.existsSync(resolvedPath)) {

fs.mkdirSync(resolvedPath, { recursive: true });

}

memory.addAction("create_folder", folderPath, { success: true });

console.log(

colors.success +

"📁 " +

path.basename(resolvedPath) +

" created" +

colors.reset

);

return { success: true, message: "Folder created successfully" };

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeRename(oldPath, newPath, memory) {

try {

const resolvedOldPath = resolveFilePath(oldPath);

const resolvedNewPath = resolveFilePath(newPath);

if (!fs.existsSync(resolvedOldPath)) {

return { success: false, message: "File not found: " + oldPath };

}

fs.renameSync(resolvedOldPath, resolvedNewPath);

memory.addAction("rename", oldPath + " -> " + newPath, { success: true });

console.log(

colors.success +

"🔄 " +

path.basename(oldPath) +

" → " +

path.basename(newPath) +

colors.reset

);

return { success: true, message: "Renamed successfully" };

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeTerminal(command, memory) {

return new Promise((resolve) => {

// Clean the command - remove any description prefixes that might have been parsed incorrectly

let cleanCommand = command.replace(

/^(Installing dependencies|Starting development server|Creating React app|Running command|Executing)\s*/,

""

);

// Additional cleaning for common issues

cleanCommand = cleanCommand.replace(

/^(Creating React app|Installing dependencies|Starting development server)\s*$/,

""

);

// If command looks like a description rather than actual command, try to infer the command

if (cleanCommand === "Creating React app" || cleanCommand === "") {

cleanCommand = "npx create-react-app calculator-app";

}

if (cleanCommand === "Installing dependencies") {

cleanCommand = "cd calculator-app && npm install";

}

if (cleanCommand === "Starting development server") {

cleanCommand = "cd calculator-app && npm start";

}

console.log(colors.info + "→ " + cleanCommand + colors.reset);

const child = spawn(cleanCommand, [], {

shell: true,

stdio: ["inherit", "pipe", "pipe"],

cwd: process.cwd(),

});

let output = "";

let error = "";

child.stdout.on("data", (data) => {

const text = data.toString();

output += text;

// Show more useful output for common operations

if (

text.includes("error") ||

text.includes("Error") ||

text.includes("SUCCESS") ||

text.includes("Done") ||

text.includes("installed") ||

text.includes("dependencies") ||

text.includes("Local:") ||

text.includes("http://") ||

text.includes("Creating a new React app") ||

text.includes("Installing packages") ||

text.includes("Happy hacking!")

) {

process.stdout.write(colors.dim + text.trim() + colors.reset + "\n");

}

});

child.stderr.on("data", (data) => {

const text = data.toString();

error += text;

// Show errors but keep them concise

if (text.trim()) {

process.stderr.write(

colors.error + "⚠ " + text.trim() + colors.reset + "\n"

);

}

});

child.on("close", (code) => {

memory.addAction("terminal", cleanCommand, {

success: code === 0,

output,

error,

});

if (code === 0) {

console.log(colors.success + "✓ Command completed" + colors.reset);

resolve({

success: true,

message: "Command executed successfully",

output,

});

} else {

console.log(

colors.error +

"✗ Command failed (exit code " +

code +

")" +

colors.reset

);

resolve({

success: false,

message: "Command failed with code " + code,

error,

});

}

});

});

}

async function executeList(target, memory) {

try {

const resolvedPath = target ? resolveFilePath(target) : process.cwd();

if (!fs.existsSync(resolvedPath)) {

return { success: false, message: "Path not found: " + target };

}

const stats = fs.statSync(resolvedPath);

if (!stats.isDirectory()) {

return { success: false, message: "Not a directory: " + target };

}

const entries = fs.readdirSync(resolvedPath, { withFileTypes: true });

const files = entries

.filter((entry) => entry.isFile())

.map((entry) => entry.name);

const folders = entries

.filter((entry) => entry.isDirectory())

.map((entry) => entry.name);

memory.addAction("list", target || ".", { success: true });

console.log(

colors.success +

"📁 " +

path.basename(resolvedPath) +

" (" +

(files.length + folders.length) +

" items)" +

colors.reset

);

return {

success: true,

message: "Listed directory contents",

files,

folders,

path: resolvedPath,

};

} catch (error) {

return { success: false, message: error.message };

}

}

async function executeSearch(query, target, memory) {

try {

const searchPath = target ? resolveFilePath(target) : process.cwd();

const results = [];

function searchInFile(filePath) {

try {

const content = fs.readFileSync(filePath, "utf-8");

const lines = content.split("\n");

const matches = [];

lines.forEach((line, index) => {

if (line.toLowerCase().includes(query.toLowerCase())) {

matches.push({

line: index + 1,

content: line.trim(),

});

}

});

if (matches.length > 0) {

results.push({

file: filePath,

matches,

});

}

} catch (err) {

// Skip files that can't be read

}

}

function searchRecursive(dir) {

const entries = fs.readdirSync(dir, { withFileTypes: true });

for (const entry of entries) {

if (entry.name.startsWith(".") || entry.name === "node_modules")

continue;

const fullPath = path.join(dir, entry.name);

if (entry.isFile()) {

searchInFile(fullPath);

} else if (entry.isDirectory()) {

searchRecursive(fullPath);

}

}

}

if (fs.statSync(searchPath).isFile()) {

searchInFile(searchPath);

} else {

searchRecursive(searchPath);

}

memory.addAction("search", '"' + query + '" in ' + (target || "."), {

success: true,

});

console.log(

colors.success +

"🔍 " +

results.length +

' files contain "' +

query +

'"' +

colors.reset

);

return {

success: true,

message: "Search completed",

results,

query,

};

} catch (error) {

return { success: false, message: error.message };

}

}

// Helper function to resolve file paths

function resolveFilePath(filePath) {

if (path.isAbsolute(filePath)) {

return filePath;

}

return path.resolve(process.cwd(), filePath);

}

// Helper function to detect project type

function detectProjectType(directory = process.cwd()) {

try {

const packageJsonPath = path.join(directory, "package.json");

if (fs.existsSync(packageJsonPath)) {

const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));

// Check for React

if (

packageJson.dependencies?.react ||

packageJson.devDependencies?.react

) {

return "react";

}

// Check for Next.js

if (packageJson.dependencies?.next || packageJson.devDependencies?.next) {

return "nextjs";

}

// Check for Vue

if (packageJson.dependencies?.vue || packageJson.devDependencies?.vue) {

return "vue";

}

// Check for Angular

if (

packageJson.dependencies?.["@angular/core"] ||

packageJson.devDependencies?.["@angular/core"]

) {

return "angular";

}

// Check for Express/Node.js server

if (

packageJson.dependencies?.express ||

packageJson.dependencies?.fastify

) {

return "node-server";

}

return "node";

}

// Check for other project indicators

if (

fs.existsSync(path.join(directory, "requirements.txt")) ||

fs.existsSync(path.join(directory, "pyproject.toml"))

) {

return "python";

}

if (fs.existsSync(path.join(directory, "Cargo.toml"))) {

return "rust";

}

if (fs.existsSync(path.join(directory, "go.mod"))) {

return "go";

}

return "generic";

} catch (error) {

return "generic";

}

}

// Helper function to check if dependencies need to be installed

function needsDependencyInstall(directory = process.cwd()) {

const packageJsonPath = path.join(directory, "package.json");

const nodeModulesPath = path.join(directory, "node_modules");

if (fs.existsSync(packageJsonPath) && !fs.existsSync(nodeModulesPath)) {

return true;

}

return false;

}

// Helper function to get smart install command based on project type

function getSmartInstallCommand(projectType, directory = process.cwd()) {

const hasYarnLock = fs.existsSync(path.join(directory, "yarn.lock"));

const hasPnpmLock = fs.existsSync(path.join(directory, "pnpm-lock.yaml"));

let packageManager = "npm";

if (hasPnpmLock) packageManager = "pnpm";

else if (hasYarnLock) packageManager = "yarn";

switch (projectType) {

case "react":

case "nextjs":

case "vue":

case "angular":

case "node":

return `${packageManager} install`;

case "python":

return "pip install -r requirements.txt";

case "rust":

return "cargo build";

case "go":

return "go mod download";

default:

return null;

}

}

// Helper function to check and execute tokens from buffer

async function checkAndExecuteTokens(

buffer,

executedCommands,

memory,

onCommand

) {

const commands = parseUnvibeTokens(buffer);

let updatedBuffer = buffer;

let executionContext = "";

for (const command of commands) {

const commandKey = command.fullMatch;

if (!executedCommands.has(commandKey)) {

executedCommands.add(commandKey);

const result = await executeUnvibeCommand(command, memory);

// Create immediate context feedback for the AI

const contextUpdate = `[EXECUTION_RESULT: ${command.action.toUpperCase()} ${

command.target

} - ${result.success ? "SUCCESS" : "FAILED: " + result.message}]`;

executionContext += contextUpdate + "\n";

if (onCommand) onCommand(command, result, contextUpdate);

// Remove executed command from buffer to avoid re-execution

updatedBuffer = updatedBuffer.replace(command.fullMatch, contextUpdate);

}

}

return { buffer: updatedBuffer, context: executionContext };

}

// Streaming AI Response Handler

async function streamAIResponse(prompt, provider, memory, onToken, onCommand) {

const selectedModel =

PROVIDERS[provider].selectedModel || PROVIDERS[provider].defaultModel;

try {

let buffer = "";

const executedCommands = new Set();

if (provider === "ollama") {

const response = await axios({

method: "post",

url: PROVIDERS.ollama.streamUrl,

data: {

model: selectedModel,

messages: [{ role: "user", content: prompt }],

stream: true,

options: {

temperature: 0.3,

top_p: 0.8,

},

},

responseType: "stream",

});

response.data.on("data", async (chunk) => {

const lines = chunk

.toString()

.split("\n")

.filter((line) => line.trim());

for (const line of lines) {

try {

const data = JSON.parse(line);

if (data.message && data.message.content) {

const content = data.message.content;

buffer += content;

// Call onToken callback

if (onToken) onToken(content);

// Check for unvibe tokens periodically (every few tokens or when closing tag detected)

if (buffer.includes("<|/unvibe_")) {

const result = await checkAndExecuteTokens(

buffer,

executedCommands,

memory,

onCommand

);

buffer = result.buffer;

// Inject execution context back into the stream so AI knows what happened

if (result.context && onToken) {

onToken(result.context);

}

}

}

} catch (e) {

// Skip invalid JSON lines

}

}

});

return new Promise((resolve) => {

response.data.on("end", () => {

resolve(buffer);

});

});

} else if (provider === "openai") {

const response = await axios({

method: "post",

url: PROVIDERS.openai.streamUrl,

headers: {

Authorization: "Bearer " + PROVIDERS.openai.apiKey,

"Content-Type": "application/json",

},

data: {

model: selectedModel,

messages: [{ role: "user", content: prompt }],

stream: true,

temperature: 0.3,

},

responseType: "stream",

});

response.data.on("data", async (chunk) => {

const lines = chunk

.toString()

.split("\n")

.filter((line) => line.trim());

for (const line of lines) {

if (line.startsWith("data: ")) {

const data = line.slice(6);

if (data === "[DONE]") return;

try {

const parsed = JSON.parse(data);

const content = parsed.choices?.[0]?.delta?.content;

if (content) {

buffer += content;

// Call onToken callback

if (onToken) onToken(content);

// Check for unvibe tokens periodically (when closing tag detected)

if (buffer.includes("<|/unvibe_")) {

const result = await checkAndExecuteTokens(

buffer,

executedCommands,

memory,

onCommand