banana-code 1.2.0

package/lib/config.js

@@ -0,0 +1,301 @@
+/**
+ * Configuration management for Banana Code
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONFIG = {
+  lmStudioUrl: 'http://localhost:1234',
+  compactMode: false,
+  maxTokens: 32000,
+  tokenWarningThreshold: 0.8, // Warn at 80% of max
+  streamingEnabled: true,
+  autoSaveHistory: true,
+  historyLimit: 50,
+  steeringEnabled: true,
+  agenticMode: true, // Enable AI tool calling (read files, search code)
+  activeModel: null, // Persisted model selection (friendly name from models.json)
+  activePrompt: 'base', // Active system prompt
+  mcpUrl: null, // MCP server URL (overrides MCP_SERVER_URL env var)
+  geminiApiKey: null, // For vision analysis fallback (Alt+V screenshots)
+  ignorePatterns: [
+    'node_modules/**',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    '.next/**',
+    'coverage/**',
+    '*.lock',
+    '*.log'
+  ]
+};
+
+class Config {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.bananaDir = path.join(projectDir, '.banana');
+    this.configPath = path.join(this.bananaDir, 'config.json');
+    this.instructionsPath = path.join(this.bananaDir, 'instructions.md');
+    this.historyDir = path.join(this.bananaDir, 'history');
+    this.config = { ...DEFAULT_CONFIG };
+    this.load();
+  }
+
+  ensureDir() {
+    if (!fs.existsSync(this.bananaDir)) {
+      fs.mkdirSync(this.bananaDir, { recursive: true });
+    }
+    if (!fs.existsSync(this.historyDir)) {
+      fs.mkdirSync(this.historyDir, { recursive: true });
+    }
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const saved = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        this.config = { ...DEFAULT_CONFIG, ...saved };
+      }
+    } catch {
+      // Use defaults
+    }
+
+    // Migrate old config: apiUrl -> lmStudioUrl
+    if (this.config.apiUrl && !this.config.lmStudioUrl) {
+      this.config.lmStudioUrl = DEFAULT_CONFIG.lmStudioUrl;
+      delete this.config.apiUrl;
+      this.save();
+    }
+
+    // Env overrides (support legacy RIPLEY_ prefix with deprecation)
+    const envUrl = process.env.BANANA_LM_STUDIO_URL || process.env.RIPLEY_LM_STUDIO_URL;
+    if (envUrl) {
+      this.config.lmStudioUrl = envUrl;
+    }
+  }
+
+  save() {
+    this.ensureDir();
+    fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+
+  get(key) {
+    return this.config[key];
+  }
+
+  set(key, value) {
+    this.config[key] = value;
+    this.save();
+  }
+
+  getAll() {
+    return { ...this.config };
+  }
+
+  // Project-specific instructions
+  // Checks BANANA.md at project root first, then .banana/instructions.md as fallback
+  getInstructions() {
+    // Primary: BANANA.md at project root (like CLAUDE.md pattern)
+    const bananaMdPath = path.join(this.projectDir, 'BANANA.md');
+    try {
+      if (fs.existsSync(bananaMdPath)) {
+        return { content: fs.readFileSync(bananaMdPath, 'utf-8'), source: 'BANANA.md' };
+      }
+    } catch {
+      // Fall through
+    }
+    // Fallback: .banana/instructions.md
+    try {
+      if (fs.existsSync(this.instructionsPath)) {
+        return { content: fs.readFileSync(this.instructionsPath, 'utf-8'), source: '.banana/instructions.md' };
+      }
+    } catch {
+      // No instructions
+    }
+    // Legacy fallback: RIPLEY.md at project root
+    const ripleyMdPath = path.join(this.projectDir, 'RIPLEY.md');
+    try {
+      if (fs.existsSync(ripleyMdPath)) {
+        return { content: fs.readFileSync(ripleyMdPath, 'utf-8'), source: 'RIPLEY.md' };
+      }
+    } catch {
+      // No legacy instructions
+    }
+    return null;
+  }
+
+  createDefaultInstructions() {
+    const bananaMdPath = path.join(this.projectDir, 'BANANA.md');
+    const template = `# BANANA.md
+
+This file provides project-specific instructions to Banana Code.
+It is automatically loaded into the AI context at the start of every conversation.
+
+## Project Overview
+<!-- Describe your project briefly -->
+
+## Code Style
+<!-- Describe your preferred code style -->
+- We use TypeScript
+- We prefer functional components with hooks
+- We use Tailwind CSS for styling
+
+## Important Notes
+<!-- Any special instructions for the AI -->
+- Always use pnpm instead of npm
+- Follow the existing patterns in the codebase
+
+## Off-Limits
+<!-- Things the AI should NOT do -->
+- Don't modify package-lock.json or pnpm-lock.yaml
+- Don't change the build configuration without asking
+`;
+    fs.writeFileSync(bananaMdPath, template);
+    return template;
+  }
+
+  // Conversation history persistence
+  saveConversation(name, history) {
+    this.ensureDir();
+    const filename = `${name.replace(/[^a-z0-9]/gi, '_')}_${Date.now()}.json`;
+    const filepath = path.join(this.historyDir, filename);
+    fs.writeFileSync(filepath, JSON.stringify({
+      name,
+      savedAt: new Date().toISOString(),
+      history
+    }, null, 2));
+    return filename;
+  }
+
+  listConversations() {
+    this.ensureDir();
+    try {
+      const files = fs.readdirSync(this.historyDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+          try {
+            const content = JSON.parse(fs.readFileSync(path.join(this.historyDir, f), 'utf-8'));
+            return {
+              filename: f,
+              name: content.name,
+              savedAt: content.savedAt,
+              messageCount: content.history?.length || 0
+            };
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean)
+        .sort((a, b) => new Date(b.savedAt) - new Date(a.savedAt));
+      return files;
+    } catch {
+      return [];
+    }
+  }
+
+  loadConversation(filename) {
+    const filepath = path.join(this.historyDir, filename);
+    try {
+      const content = JSON.parse(fs.readFileSync(filepath, 'utf-8'));
+      return content.history || [];
+    } catch {
+      return null;
+    }
+  }
+
+  deleteConversation(filename) {
+    const filepath = path.join(this.historyDir, filename);
+    try {
+      fs.unlinkSync(filepath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Hooks config
+  getHooksPath() {
+    return path.join(this.bananaDir, 'hooks.json');
+  }
+
+  getHooks() {
+    try {
+      const hooksPath = this.getHooksPath();
+      if (fs.existsSync(hooksPath)) {
+        return JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+      }
+    } catch {
+      // Invalid hooks.json
+    }
+    return {};
+  }
+
+  saveHooks(hookConfig) {
+    this.ensureDir();
+    fs.writeFileSync(this.getHooksPath(), JSON.stringify(hookConfig, null, 2));
+  }
+}
+
+// ─── Global Config (~/.banana/) ──────────────────────────────────────────────
+
+const GLOBAL_BANANA_DIR = path.join(require('os').homedir(), '.banana');
+
+class GlobalConfig {
+  constructor() {
+    this.bananaDir = GLOBAL_BANANA_DIR;
+    this.configPath = path.join(this.bananaDir, 'config.json');
+    this.instructionsPath = path.join(this.bananaDir, 'BANANA.md');
+    this.commandsDir = path.join(this.bananaDir, 'commands');
+    this.config = {};
+    this.load();
+  }
+
+  ensureDir() {
+    for (const dir of [this.bananaDir, this.commandsDir, path.join(this.bananaDir, 'logs')]) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        this.config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+      }
+    } catch {
+      this.config = {};
+    }
+  }
+
+  save() {
+    this.ensureDir();
+    fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+
+  get(key) {
+    return this.config[key];
+  }
+
+  set(key, value) {
+    this.config[key] = value;
+    this.save();
+  }
+
+  /**
+   * Get global instructions from ~/.banana/BANANA.md
+   */
+  getInstructions() {
+    try {
+      if (fs.existsSync(this.instructionsPath)) {
+        return { content: fs.readFileSync(this.instructionsPath, 'utf-8'), source: '~/.banana/BANANA.md' };
+      }
+    } catch {
+      // No global instructions
+    }
+    return null;
+  }
+}
+
+module.exports = { Config, GlobalConfig, GLOBAL_BANANA_DIR };

package/lib/contextBuilder.js

@@ -0,0 +1,324 @@
+/**
+ * Context Builder - Build project context for AI
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Directories to always ignore
+const IGNORED_DIRS = [
+  'node_modules', '.git', '.next', 'dist', 'build', '.cache',
+  'coverage', '.nyc_output', '.vercel', '.netlify', '.svelte-kit',
+  '__pycache__', 'venv', '.venv', 'env', '.env',
+  '.banana', '.ripley', '.idea', '.vscode'
+];
+
+// Files to always ignore
+const IGNORED_FILES = [
+  '.DS_Store', 'Thumbs.db', '.gitkeep',
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'
+];
+
+// Priority files to always include if they exist
+const PRIORITY_FILES = [
+  'package.json', 'tsconfig.json', 'README.md', 'README.txt',
+  '.env.example', 'next.config.js', 'next.config.mjs', 'next.config.ts',
+  'vite.config.js', 'vite.config.ts', 'tailwind.config.js', 'tailwind.config.ts',
+  'prisma/schema.prisma', 'drizzle.config.ts'
+];
+
+// Extensions for source files
+const SOURCE_EXTENSIONS = [
+  '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte',
+  '.py', '.rb', '.go', '.rs', '.java', '.kt',
+  '.css', '.scss', '.sass', '.less',
+  '.html', '.htm', '.json', '.yaml', '.yml', '.toml',
+  '.md', '.mdx', '.sql', '.graphql', '.gql'
+];
+
+class ContextBuilder {
+  constructor(fileManager, ignorePatterns = []) {
+    this.fileManager = fileManager;
+    this.projectDir = fileManager.projectDir;
+    this.customIgnores = ignorePatterns;
+    this.loadedFiles = new Map(); // path -> content
+  }
+
+  /**
+   * Load .gitignore patterns
+   */
+  loadGitignore() {
+    const gitignorePath = path.join(this.projectDir, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      try {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        return content
+          .split('\n')
+          .map(line => line.trim())
+          .filter(line => line && !line.startsWith('#'));
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+
+  /**
+   * Check if path should be ignored
+   */
+  shouldIgnore(relativePath) {
+    const basename = path.basename(relativePath);
+    const parts = relativePath.split(path.sep);
+
+    // Check ignored directories
+    for (const dir of IGNORED_DIRS) {
+      if (parts.includes(dir)) return true;
+    }
+
+    // Check ignored files
+    if (IGNORED_FILES.includes(basename)) return true;
+
+    // Check custom patterns (simple matching)
+    for (const pattern of this.customIgnores) {
+      if (pattern.endsWith('/') || pattern.endsWith('\\')) {
+        // Directory pattern
+        const dirName = pattern.slice(0, -1);
+        if (parts.includes(dirName)) return true;
+      } else if (pattern.startsWith('*.')) {
+        // Extension pattern
+        const ext = pattern.slice(1);
+        if (relativePath.endsWith(ext)) return true;
+      } else if (relativePath.includes(pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Recursively scan directory structure
+   * @param {string} dir - Directory to scan
+   * @param {number} depth - Current depth
+   * @param {number} maxDepth - Maximum recursion depth
+   * @param {number} maxFiles - Maximum total files to collect (prevents runaway scans)
+   * @param {object} counter - Shared counter across recursive calls
+   */
+  scanDirectory(dir = this.projectDir, depth = 0, maxDepth = 6, maxFiles = 5000, counter = { count: 0 }) {
+    if (depth > maxDepth) return [];
+    if (counter.count >= maxFiles) return [];
+
+    const results = [];
+    const relativePath = path.relative(this.projectDir, dir) || '.';
+
+    if (this.shouldIgnore(relativePath)) return [];
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (counter.count >= maxFiles) break;
+
+        const fullPath = path.join(dir, entry.name);
+        const entryRelPath = path.relative(this.projectDir, fullPath);
+
+        if (this.shouldIgnore(entryRelPath)) continue;
+
+        if (entry.isDirectory()) {
+          results.push({
+            type: 'dir',
+            name: entry.name,
+            path: entryRelPath,
+            depth
+          });
+          results.push(...this.scanDirectory(fullPath, depth + 1, maxDepth, maxFiles, counter));
+        } else {
+          const ext = path.extname(entry.name).toLowerCase();
+          const isSource = SOURCE_EXTENSIONS.includes(ext);
+          results.push({
+            type: 'file',
+            name: entry.name,
+            path: entryRelPath,
+            isSource,
+            depth
+          });
+          counter.count++;
+        }
+      }
+    } catch {
+      // Ignore permission errors
+    }
+
+    return results;
+  }
+
+  /**
+   * Build a tree string from scan results
+   */
+  buildTreeString(items, maxItems = 100) {
+    let tree = '';
+    let count = 0;
+
+    for (const item of items) {
+      if (count >= maxItems) {
+        tree += `\n... and ${items.length - count} more items`;
+        break;
+      }
+
+      const indent = '  '.repeat(item.depth);
+      const icon = item.type === 'dir' ? '📁' : '📄';
+      tree += `${indent}${icon} ${item.name}\n`;
+      count++;
+    }
+
+    return tree;
+  }
+
+  /**
+   * Load priority files
+   */
+  loadPriorityFiles() {
+    for (const file of PRIORITY_FILES) {
+      const filePath = path.join(this.projectDir, file);
+      if (fs.existsSync(filePath)) {
+        const result = this.fileManager.readFile(filePath);
+        if (result.success) {
+          this.loadedFiles.set(file, result.content);
+        }
+      }
+    }
+  }
+
+  /**
+   * Load a specific file into context
+   */
+  loadFile(filePath) {
+    const relativePath = path.isAbsolute(filePath)
+      ? path.relative(this.projectDir, filePath)
+      : filePath;
+
+    if (this.loadedFiles.has(relativePath)) {
+      return { success: true, alreadyLoaded: true };
+    }
+
+    const result = this.fileManager.readFile(filePath);
+    if (result.success) {
+      this.loadedFiles.set(relativePath, result.content);
+      return { success: true, path: relativePath };
+    }
+    return result;
+  }
+
+  /**
+   * Unload a file from context
+   */
+  unloadFile(filePath) {
+    const relativePath = path.isAbsolute(filePath)
+      ? path.relative(this.projectDir, filePath)
+      : filePath;
+
+    if (this.loadedFiles.has(relativePath)) {
+      this.loadedFiles.delete(relativePath);
+      return { success: true };
+    }
+    return { success: false, error: 'File not in context' };
+  }
+
+  /**
+   * Reload a file in context (for watch mode)
+   */
+  reloadFile(filePath) {
+    const relativePath = path.isAbsolute(filePath)
+      ? path.relative(this.projectDir, filePath)
+      : filePath;
+
+    if (!this.loadedFiles.has(relativePath)) {
+      return { success: false, error: 'File not in context' };
+    }
+
+    const result = this.fileManager.readFile(filePath);
+    if (result.success) {
+      this.loadedFiles.set(relativePath, result.content);
+      return { success: true, path: relativePath };
+    }
+    return result;
+  }
+
+  /**
+   * Get list of loaded files
+   */
+  getLoadedFiles() {
+    return Array.from(this.loadedFiles.keys());
+  }
+
+  /**
+   * Clear all loaded files
+   */
+  clearFiles() {
+    this.loadedFiles.clear();
+  }
+
+  /**
+   * Build the full context string for AI
+   */
+  buildContext() {
+    // Load gitignore patterns
+    this.customIgnores = [...this.customIgnores, ...this.loadGitignore()];
+
+    // Load priority files first
+    this.loadPriorityFiles();
+
+    // Scan directory structure
+    const structure = this.scanDirectory();
+    const tree = this.buildTreeString(structure);
+
+    // Build context string
+    let context = '';
+
+    // Project info
+    const packageJson = this.loadedFiles.get('package.json');
+    if (packageJson) {
+      try {
+        const pkg = JSON.parse(packageJson);
+        context += `## Project: ${pkg.name || 'Unknown'}\n`;
+        if (pkg.description) context += `Description: ${pkg.description}\n`;
+        context += '\n';
+      } catch {
+        // Invalid JSON, skip
+      }
+    }
+
+    // Directory structure
+    context += `## Project Structure\n\`\`\`\n${tree}\`\`\`\n\n`;
+
+    // Loaded files
+    context += `## Files in Context (${this.loadedFiles.size})\n\n`;
+
+    for (const [filePath, content] of this.loadedFiles) {
+      const ext = path.extname(filePath).slice(1) || 'txt';
+      context += `### ${filePath}\n\`\`\`${ext}\n${content}\n\`\`\`\n\n`;
+    }
+
+    return context;
+  }
+
+  /**
+   * Get a summary of the context (for display)
+   */
+  getSummary() {
+    const structure = this.scanDirectory();
+    const files = structure.filter(i => i.type === 'file');
+    const dirs = structure.filter(i => i.type === 'dir');
+    const sourceFiles = files.filter(f => f.isSource);
+
+    return {
+      totalFiles: files.length,
+      totalDirs: dirs.length,
+      sourceFiles: sourceFiles.length,
+      loadedFiles: this.loadedFiles.size,
+      loadedFilesList: this.getLoadedFiles()
+    };
+  }
+}
+
+module.exports = ContextBuilder;