draco-cli 0.0.0-stage → 3.0.2

package/src/core/logger.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const theme = require('../ui/theme.js');
+
+class Logger {
+  constructor(options = {}) {
+    this.level = options.level || 'info';
+    this.logDir = options.logDir || path.join(os.homedir(), '.draco', 'logs');
+    this.maxFileSize = options.maxFileSize || 5 * 1024 * 1024;
+    this.maxFiles = options.maxFiles || 5;
+    this.console = options.console !== false;
+    this.file = options.file !== false;
+
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3,
+      trace: 4,
+    };
+
+    this.colors = {
+      error: '\x1b[31m',
+      warn: '\x1b[33m',
+      info: '\x1b[36m',
+      debug: '\x1b[35m',
+      trace: '\x1b[90m',
+      reset: '\x1b[0m',
+    };
+
+    if (this.file) {
+      try {
+        if (!fs.existsSync(this.logDir)) {
+          fs.mkdirSync(this.logDir, { recursive: true });
+        }
+      } catch (err) {
+        theme.printError(`Failed to create log directory: ${err.message}`);
+        this.file = false;
+      }
+    }
+  }
+
+  shouldLog(level) {
+    return this.levels[level] <= this.levels[this.level];
+  }
+
+  formatMessage(level, message, data) {
+    const timestamp = new Date().toISOString();
+    let formatted = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
+
+    if (data !== undefined) {
+      if (data instanceof Error) {
+        formatted += `\n${data.stack || data.message}`;
+      } else if (typeof data === 'object') {
+        formatted += `\n${JSON.stringify(data, null, 2)}`;
+      } else {
+        formatted += ` ${data}`;
+      }
+    }
+
+    return formatted;
+  }
+
+  writeToFile(level, message) {
+    if (!this.file) return;
+
+    try {
+      const logFile = path.join(this.logDir, `${level}.log`);
+      const formatted = this.formatMessage(level, message);
+
+      fs.appendFileSync(logFile, formatted + '\n');
+
+      const stats = fs.statSync(logFile);
+      if (stats.size > this.maxFileSize) {
+        this.rotateFile(logFile);
+      }
+    } catch (error) {
+      theme.printError(`Failed to write to log file: ${error.message}`);
+    }
+  }
+
+  rotateFile(filePath) {
+    try {
+      for (let i = this.maxFiles - 1; i > 0; i--) {
+        const oldFile = `${filePath}.${i}`;
+        const newFile = `${filePath}.${i + 1}`;
+
+        if (fs.existsSync(oldFile)) {
+          if (i === this.maxFiles - 1) {
+            fs.unlinkSync(oldFile);
+          } else {
+            fs.renameSync(oldFile, newFile);
+          }
+        }
+      }
+
+      if (fs.existsSync(filePath)) {
+        fs.renameSync(filePath, `${filePath}.1`);
+      }
+    } catch (error) {
+      theme.printError(`Failed to rotate log file: ${error.message}`);
+    }
+  }
+
+  log(level, message, data) {
+    if (!this.shouldLog(level)) return;
+
+    const formatted = this.formatMessage(level, message, data);
+
+    if (this.console) {
+      if (level === 'error') {
+        console.error(theme.errorTag(formatted));
+      } else {
+        const color = this.colors[level] || '';
+        console.log(`${color}${formatted}${this.colors.reset}`);
+      }
+    }
+
+    this.writeToFile(level, formatted);
+  }
+
+  error(message, data) {
+    this.log('error', message, data);
+  }
+
+  warn(message, data) {
+    this.log('warn', message, data);
+  }
+
+  info(message, data) {
+    this.log('info', message, data);
+  }
+
+  debug(message, data) {
+    this.log('debug', message, data);
+  }
+
+  trace(message, data) {
+    this.log('trace', message, data);
+  }
+
+  setLevel(level) {
+    if (this.levels[level] === undefined) {
+      throw new Error(`Invalid log level: ${level}. Must be one of: ${Object.keys(this.levels).join(', ')}`);
+    }
+    this.level = level;
+  }
+
+  getLevel() {
+    return this.level;
+  }
+
+  getRecentLogs(level = 'info', lines = 50) {
+    if (!this.file) return [];
+    try {
+      const logFile = path.join(this.logDir, `${level}.log`);
+      if (!fs.existsSync(logFile)) return [];
+      const content = fs.readFileSync(logFile, 'utf8');
+      const allLines = content.split('\n').filter(Boolean);
+      return allLines.slice(-lines);
+    } catch (err) {
+      return [];
+    }
+  }
+
+  child(options = {}) {
+    return new Logger({
+      ...this,
+      ...options,
+    });
+  }
+
+  clearLogs() {
+    if (!this.file) return false;
+    try {
+      const files = fs.readdirSync(this.logDir);
+      for (const file of files) {
+        if (file.endsWith('.log')) {
+          fs.unlinkSync(path.join(this.logDir, file));
+        }
+      }
+      return true;
+    } catch (error) {
+      theme.printError(`Failed to clear logs: ${error.message}`);
+      return false;
+    }
+  }
+
+  getLogSize(level = 'info') {
+    if (!this.file) return 0;
+    try {
+      const logFile = path.join(this.logDir, `${level}.log`);
+      if (!fs.existsSync(logFile)) return 0;
+      const stats = fs.statSync(logFile);
+      return stats.size;
+    } catch (error) {
+      return 0;
+    }
+  }
+}
+
+const logger = new Logger();
+
+module.exports = { Logger, logger };

package/src/core/middleware.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const theme = require('../ui/theme.js');
+
+class MiddlewarePipeline {
+  constructor() {
+    this.middlewares = [];
+  }
+
+  use(middleware) {
+    if (typeof middleware !== 'function') {
+      throw new Error('Middleware must be a function');
+    }
+    this.middlewares.push(middleware);
+    return this;
+  }
+
+  remove(middleware) {
+    const index = this.middlewares.indexOf(middleware);
+    if (index !== -1) {
+      this.middlewares.splice(index, 1);
+    }
+    return this;
+  }
+
+  async execute(context) {
+    let index = 0;
+    const next = async () => {
+      if (index < this.middlewares.length) {
+        const middleware = this.middlewares[index++];
+        await middleware(context, next);
+      }
+    };
+
+    await next();
+    return context;
+  }
+
+  clear() {
+    this.middlewares = [];
+    return this;
+  }
+
+  list() {
+    return [...this.middlewares];
+  }
+}
+
+const loggingMiddleware = async (context, next) => {
+  const start = Date.now();
+  console.log(`[${new Date().toISOString()}] Request started`);
+
+  await next();
+
+  const duration = Date.now() - start;
+  console.log(`[${new Date().toISOString()}] Request completed in ${duration}ms`);
+};
+
+const errorMiddleware = async (context, next) => {
+  try {
+    await next();
+  } catch (error) {
+    theme.printError(error.message);
+    context.error = error;
+  }
+};
+
+const validationMiddleware = async (context, next) => {
+  if (!context.input || context.input.trim() === '') {
+    throw new Error('Input cannot be empty');
+  }
+  await next();
+};
+
+const rateLimitMiddleware = (maxRequests = 100, windowMs = 60000) => {
+  const requests = new Map();
+
+  return async (context, next) => {
+    const now = Date.now();
+    const windowStart = now - windowMs;
+    const clientRequests = (requests.get(context.clientId) || []).filter(
+      (t) => t > windowStart
+    );
+
+    if (clientRequests.length >= maxRequests) {
+      throw new Error('Rate limit exceeded');
+    }
+
+    clientRequests.push(now);
+    requests.set(context.clientId, clientRequests);
+
+    await next();
+  };
+};
+
+module.exports = {
+  MiddlewarePipeline,
+  loggingMiddleware,
+  errorMiddleware,
+  validationMiddleware,
+  rateLimitMiddleware,
+};

package/src/core/plugin-manager.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const theme = require('../ui/theme.js');
+
+class PluginManager {
+  constructor(config) {
+    this.config = config;
+    this.plugins = new Map();
+    this.hooks = new Map();
+    this.pluginDir = path.join(os.homedir(), '.draco', 'plugins');
+  }
+
+  async loadPlugins() {
+    if (!fs.existsSync(this.pluginDir)) {
+      fs.mkdirSync(this.pluginDir, { recursive: true });
+      return;
+    }
+
+    const pluginFiles = fs.readdirSync(this.pluginDir).filter((f) => f.endsWith('.js'));
+
+    for (const file of pluginFiles) {
+      try {
+        await this.loadPlugin(path.join(this.pluginDir, file));
+      } catch (error) {
+        theme.printError(`Failed to load plugin ${file}: ${error.message}`);
+      }
+    }
+  }
+
+  async loadPlugin(pluginPath) {
+    const pluginModule = require(pluginPath);
+    const plugin = typeof pluginModule === 'function' ? pluginModule() : pluginModule;
+
+    if (!plugin || !plugin.name) {
+      throw new Error('Plugin must export a name');
+    }
+
+    const pluginInfo = {
+      name: plugin.name,
+      version: plugin.version || '1.0.0',
+      description: plugin.description || '',
+      author: plugin.author || '',
+      hooks: plugin.hooks || {},
+      commands: plugin.commands || [],
+      initialized: false,
+    };
+
+    if (plugin.init) {
+      await plugin.init(this.config);
+      pluginInfo.initialized = true;
+    }
+
+    this.plugins.set(plugin.name, pluginInfo);
+
+    for (const [hookName, hookFn] of Object.entries(pluginInfo.hooks)) {
+      if (!this.hooks.has(hookName)) {
+        this.hooks.set(hookName, []);
+      }
+      this.hooks.get(hookName).push({
+        plugin: plugin.name,
+        handler: hookFn,
+      });
+    }
+
+    return pluginInfo;
+  }
+
+  async unloadPlugin(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) return false;
+
+    for (const [hookName, hookHandlers] of this.hooks) {
+      const filtered = hookHandlers.filter((h) => h.plugin !== name);
+      if (filtered.length === 0) {
+        this.hooks.delete(hookName);
+      } else {
+        this.hooks.set(hookName, filtered);
+      }
+    }
+
+    this.plugins.delete(name);
+    return true;
+  }
+
+  async executeHook(hookName, data) {
+    const handlers = this.hooks.get(hookName) || [];
+    let result = data;
+
+    for (const { plugin, handler } of handlers) {
+      try {
+        result = await handler(result);
+      } catch (error) {
+        theme.printError(`Hook ${hookName} failed in plugin ${plugin}: ${error.message}`);
+      }
+    }
+
+    return result;
+  }
+
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+
+  listPlugins() {
+    return Array.from(this.plugins.values());
+  }
+
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+
+  async installPlugin(source) {
+    const pluginName = path.basename(source, '.js');
+    const destPath = path.join(this.pluginDir, `${pluginName}.js`);
+
+    if (fs.existsSync(destPath)) {
+      throw new Error(`Plugin ${pluginName} already exists`);
+    }
+
+    if (source.startsWith('http')) {
+      const response = await fetch(source);
+      const code = await response.text();
+      fs.writeFileSync(destPath, code);
+    } else {
+      fs.copyFileSync(source, destPath);
+    }
+
+    return this.loadPlugin(destPath);
+  }
+
+  async uninstallPlugin(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) return false;
+
+    await this.unloadPlugin(name);
+
+    const pluginPath = path.join(this.pluginDir, `${name}.js`);
+    if (fs.existsSync(pluginPath)) {
+      fs.unlinkSync(pluginPath);
+    }
+
+    return true;
+  }
+}
+
+module.exports = { PluginManager };

package/src/core/prompt.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function loadAgentsMd(workspaceRoot) {
+  const p = path.join(workspaceRoot, 'AGENTS.md');
+  try {
+    const stat = fs.statSync(p);
+    if (!stat.isFile()) return '';
+    return fs.readFileSync(p, 'utf8').slice(0, 32000);
+  } catch {
+    return '';
+  }
+}
+
+function buildSystemPrompt(cfg, agentsMd) {
+  const toolsLine =
+    'Your tools: readFile, writeFile, makeDirectory, executeShell, webFetch, webSearch.';
+  const webLine =
+    'webSearch is for open-ended discovery ("find out about X"); webFetch is for retrieving a specific URL you already have. Prefer local project context and only use the web when the task clearly needs current or external information.';
+  const lines = [
+    `You are Draco, an autonomous terminal-based coding agent working inside the user's workspace at ${cfg.workspaceRoot}.`,
+    'You are confined to that directory: every file operation is sandboxed to it and paths outside are rejected.',
+    toolsLine,
+    '- Use the tools proactively to actually perform work instead of describing hypothetical edits.',
+    '- Read a file with readFile before editing it unless its contents are already in context.',
+    '- Shell commands and file writes may require user approval depending on the current approval mode; batch related commands sensibly.',
+    '- If a tool call fails, read the error message and adapt; never repeat the identical failing call.',
+    webLine,
+    'Be concise, technical, and act on the request directly. Format answers in Markdown.',
+  ];
+  if (agentsMd && agentsMd.trim()) {
+    lines.push(
+      '',
+      'Project instructions from AGENTS.md (follow these carefully):',
+      '---',
+      agentsMd.trim(),
+      '---'
+    );
+  }
+  return lines.join('\n');
+}
+
+module.exports = { buildSystemPrompt, loadAgentsMd };

package/src/core/session-history.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const theme = require('../ui/theme.js');
+
+class SessionHistory {
+  constructor(config) {
+    this.config = config;
+    this.historyFile = path.join(
+      os.homedir(),
+      '.draco',
+      'history',
+      `${config.workspaceHash || 'default'}.json`
+    );
+    this.sessions = [];
+    this.currentIndex = -1;
+    this.maxSessions = 100;
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.historyFile)) {
+        const data = fs.readFileSync(this.historyFile, 'utf8');
+        this.sessions = JSON.parse(data);
+        this.currentIndex = this.sessions.length - 1;
+      }
+    } catch (error) {
+      theme.printError(`Failed to load history: ${error.message}`);
+      this.sessions = [];
+    }
+  }
+
+  save() {
+    try {
+      const dir = path.dirname(this.historyFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      const sessionsToSave = this.sessions.slice(-this.maxSessions);
+      fs.writeFileSync(this.historyFile, JSON.stringify(sessionsToSave, null, 2));
+    } catch (error) {
+      theme.printError(`Failed to save history: ${error.message}`);
+    }
+  }
+
+  addSession(session) {
+    const historyEntry = {
+      id: Date.now().toString(36),
+      timestamp: new Date().toISOString(),
+      model: session.model,
+      prompt: session.prompt?.substring(0, 200) || '',
+      tokenCount: session.tokenCount || 0,
+      messageCount: session.messages?.length || 0,
+      duration: session.duration || 0,
+      workspace: this.config.workspaceRoot,
+      tags: session.tags || [],
+    };
+
+    this.sessions.push(historyEntry);
+    this.currentIndex = this.sessions.length - 1;
+    this.save();
+
+    return historyEntry;
+  }
+
+  updateSession(id, updates) {
+    const index = this.sessions.findIndex((s) => s.id === id);
+    if (index === -1) return null;
+
+    this.sessions[index] = { ...this.sessions[index], ...updates };
+    this.save();
+
+    return this.sessions[index];
+  }
+
+  getSession(id) {
+    return this.sessions.find((s) => s.id === id) || null;
+  }
+
+  getRecentSessions(count = 10) {
+    return this.sessions.slice(-count).reverse();
+  }
+
+  searchSessions(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.sessions
+      .filter(
+        (s) =>
+          s.prompt.toLowerCase().includes(lowerQuery) ||
+          s.model.toLowerCase().includes(lowerQuery) ||
+          s.tags.some((t) => t.toLowerCase().includes(lowerQuery))
+      )
+      .reverse();
+  }
+
+  clearHistory() {
+    this.sessions = [];
+    this.currentIndex = -1;
+    this.save();
+  }
+
+  getStats() {
+    const totalSessions = this.sessions.length;
+    const totalTokens = this.sessions.reduce((sum, s) => sum + (s.tokenCount || 0), 0);
+    const totalMessages = this.sessions.reduce((sum, s) => sum + (s.messageCount || 0), 0);
+
+    const modelCounts = {};
+    for (const session of this.sessions) {
+      modelCounts[session.model] = (modelCounts[session.model] || 0) + 1;
+    }
+
+    const tagCounts = {};
+    for (const session of this.sessions) {
+      for (const tag of session.tags) {
+        tagCounts[tag] = (tagCounts[tag] || 0) + 1;
+      }
+    }
+
+    return {
+      totalSessions,
+      totalTokens,
+      totalMessages,
+      modelCounts,
+      tagCounts,
+      averageTokensPerSession: totalSessions > 0 ? Math.round(totalTokens / totalSessions) : 0,
+    };
+  }
+
+  exportHistory(format = 'json') {
+    if (format === 'json') {
+      return JSON.stringify(this.sessions, null, 2);
+    }
+
+    if (format === 'markdown') {
+      let md = '# Session History\n\n';
+      for (const session of this.sessions.reverse()) {
+        md += `## ${session.timestamp}\n`;
+        md += `- **Model**: ${session.model}\n`;
+        md += `- **Prompt**: ${session.prompt}\n`;
+        md += `- **Tokens**: ${session.tokenCount}\n`;
+        md += `- **Messages**: ${session.messageCount}\n\n`;
+      }
+      return md;
+    }
+
+    if (format === 'csv') {
+      const headers = ['timestamp', 'model', 'prompt', 'tokenCount', 'messageCount', 'duration'];
+      const rows = this.sessions.map((s) =>
+        headers.map((h) => `"${String(s[h] || '').replace(/"/g, '""')}"`).join(',')
+      );
+      return [headers.join(','), ...rows].join('\n');
+    }
+
+    throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+module.exports = { SessionHistory };