draco-cli 0.0.0-stage → 3.0.3

package/src/config.js

@@ -0,0 +1,218 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let VERSION = '0.0.0';
+try {
+  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+  if (pkg && pkg.version) VERSION = pkg.version;
+} catch {
+  // keep fallback version
+}
+
+const DEFAULT_API_BASE = 'https://opencode.ai';
+const DEFAULT_MODEL = 'nemotron-3-ultra-free';
+const DEFAULT_FALLBACK_CHAIN = [
+  'nemotron-3-ultra-free',
+  'deepseek-v4-flash-free',
+  'big-pickle',
+  'mimo-v2.5-free',
+];
+const KNOWN_FREE_MODELS = DEFAULT_FALLBACK_CHAIN.slice();
+
+const CHAT_TIMEOUT_MS = 60000;
+const MODELS_TIMEOUT_MS = 15000;
+const SHELL_TIMEOUT_MS = 45000;
+const SHELL_MAX_BUFFER = 8 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 30000;
+const FETCH_MAX_BYTES = 5 * 1024 * 1024;
+const READ_FILE_MAX_BYTES = 256 * 1024;
+
+function configFilePath() {
+  return path.join(os.homedir(), '.draco', 'config.json');
+}
+
+function loadEnvFile(dir) {
+  const p = path.join(dir || process.cwd(), '.env');
+  let raw;
+  try {
+    raw = fs.readFileSync(p, 'utf8');
+  } catch {
+    return;
+  }
+  for (const lineRaw of raw.split(/\r?\n/)) {
+    const line = lineRaw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (!(key in process.env)) process.env[key] = value;
+  }
+}
+
+function loadPersisted() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configFilePath(), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function persistConfig(patch) {
+  const next = { ...loadPersisted() };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined) delete next[key];
+    else next[key] = value;
+  }
+  fs.mkdirSync(path.dirname(configFilePath()), { recursive: true });
+  fs.writeFileSync(configFilePath(), JSON.stringify(next, null, 2) + '\n');
+  return next;
+}
+
+const APPROVAL_MODES = ['suggest', 'auto-edit', 'full-auto'];
+const DEFAULT_APPROVALS = 'suggest';
+
+function configDirPath() {
+  return path.join(os.homedir(), '.draco');
+}
+
+function configFilePath() {
+  return path.join(configDirPath(), 'config.json');
+}
+
+function sessionsDir() {
+  return path.join(configDirPath(), 'sessions');
+}
+
+function mcpConfigPath() {
+  return path.join(configDirPath(), 'mcp.json');
+}
+
+function loadMcpConfig() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(mcpConfigPath(), 'utf8'));
+    const servers = parsed && typeof parsed === 'object' ? parsed.mcpServers : null;
+    return servers && typeof servers === 'object' ? servers : {};
+  } catch {
+    return {};
+  }
+}
+
+function sessionFileFor(cwd) {
+  const key = cwd.replace(/[^A-Za-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(-80) || 'root';
+  return path.join(sessionsDir(), `${key}.json`);
+}
+
+function validateConfig(config) {
+  const warnings = [];
+  
+  if (!config.apiKey) {
+    warnings.push('No API key configured. Set OPENCODE_ZEN_KEY or enter when prompted.');
+  }
+  
+  if (config.model && !KNOWN_FREE_MODELS.includes(config.model) && !config.model.includes('/')) {
+    warnings.push(`Model "${config.model}" is not in the known free models list.`);
+  }
+  
+  if (config.fallbackChain && config.fallbackChain.length === 0) {
+    warnings.push('Fallback chain is empty. Using default chain.');
+    config.fallbackChain = DEFAULT_FALLBACK_CHAIN.slice();
+  }
+  
+  if (config.searchProvider === 'brave' && !config.searchApiKey) {
+    warnings.push('Brave search selected but no API key. Will fall back to DuckDuckGo.');
+  }
+  
+  return { config, warnings };
+}
+
+function resolveConfig(cliFlags) {
+  loadEnvFile();
+  const persisted = loadPersisted();
+  const env = process.env;
+  const cli = cliFlags || {};
+
+  const model =
+    cli.model || env.DRACO_MODEL || persisted.model || DEFAULT_MODEL;
+
+  let yolo = false;
+  if (cli.yolo) yolo = true;
+  else if (env.DRACO_YOLO === 'true') yolo = true;
+  else if (env.DRACO_YOLO === 'false') yolo = false;
+  else if (typeof persisted.yolo === 'boolean') yolo = persisted.yolo;
+
+  let approvals = cli.approvals || env.DRACO_APPROVALS || persisted.approvals;
+  if (!APPROVAL_MODES.includes(approvals)) approvals = DEFAULT_APPROVALS;
+  if (yolo) approvals = 'full-auto';
+
+  const fallbackChain =
+    Array.isArray(persisted.fallbackChain) && persisted.fallbackChain.length > 0
+      ? persisted.fallbackChain
+      : DEFAULT_FALLBACK_CHAIN.slice();
+
+  let apiKey = env.OPENCODE_ZEN_KEY || '';
+  let keySource = null;
+  if (apiKey) {
+    keySource = 'environment';
+  } else if (typeof persisted.apiKey === 'string' && persisted.apiKey.trim()) {
+    apiKey = persisted.apiKey.trim();
+    keySource = 'saved';
+  }
+
+  const config = {
+    version: VERSION,
+    apiKey,
+    keySource,
+    apiBase: (env.DRACO_API_BASE || DEFAULT_API_BASE).replace(/\/+$/, ''),
+    model,
+    yolo,
+    approvals,
+    fallbackChain,
+    searchProvider: env.DRACO_SEARCH_PROVIDER || 'brave',
+    searchApiKey: env.DRACO_SEARCH_API_KEY || '',
+    workspaceRoot: process.cwd(),
+    configFile: configFilePath(),
+  };
+
+  const validated = validateConfig(config);
+  validated.config.warnings = validated.warnings;
+  return validated.config;
+}
+
+module.exports = {
+  VERSION,
+  APPROVAL_MODES,
+  DEFAULT_APPROVALS,
+  DEFAULT_API_BASE,
+  DEFAULT_MODEL,
+  DEFAULT_FALLBACK_CHAIN,
+  KNOWN_FREE_MODELS,
+  CHAT_TIMEOUT_MS,
+  MODELS_TIMEOUT_MS,
+  SHELL_TIMEOUT_MS,
+  SHELL_MAX_BUFFER,
+  FETCH_TIMEOUT_MS,
+  FETCH_MAX_BYTES,
+  READ_FILE_MAX_BYTES,
+  configFilePath,
+  configDirPath,
+  sessionsDir,
+  sessionFileFor,
+  mcpConfigPath,
+  loadMcpConfig,
+  loadEnvFile,
+  loadPersisted,
+  persistConfig,
+  resolveConfig,
+};
+

package/src/core/approvals.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const APPROVAL_MODES = ['suggest', 'auto-edit', 'full-auto'];
+
+function approvalMode(ctx) {
+  if (!ctx || !ctx.cfg) return 'suggest';
+  if (ctx.cfg.yolo) return 'full-auto';
+  return ctx.cfg.approvals || 'suggest';
+}
+
+async function gate(ctx, question, autoModes) {
+  const mode = approvalMode(ctx);
+  if (autoModes.includes(mode)) return true;
+  if (typeof ctx.ask !== 'function') return false;
+  const answer = await ctx.ask(question);
+  const normalized = String(answer || '').trim().toLowerCase();
+  return normalized === 'y' || normalized === 'yes';
+}
+
+module.exports = { APPROVAL_MODES, approvalMode, gate };

package/src/core/compaction.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { streamChatCompletion } = require('../providers/openai-compatible.js');
+const ui = require('../ui/terminal.js');
+
+function simplifyMessageForSummary(message) {
+  let content = message.content;
+  if (Array.isArray(content)) {
+    const texts = content
+      .filter((part) => part && part.type === 'text')
+      .map((part) => part.text);
+    content = texts.join('\n') || '[media attachment]';
+  }
+  if (message.role === 'tool') {
+    return { role: 'user', content: `[tool result] ${String(content).slice(0, 2000)}` };
+  }
+  return {
+    role: message.role === 'assistant' ? 'assistant' : 'user',
+    content: String(content ?? ''),
+  };
+}
+
+const SUMMARY_SYSTEM_PROMPT =
+  'Summarize this coding-agent conversation. Capture: the user goals, files created/modified (with paths), key decisions, commands run, errors hit and their fixes, and any unfinished next steps. Be dense and factual.';
+
+async function compactConversation({ cfg, model, messages }) {
+  const spinner = new ui.Spinner('Compacting conversation…');
+  spinner.start();
+  const controller = new AbortController();
+  let summary = '';
+  try {
+    await streamChatCompletion({
+      cfg,
+      model,
+      messages: [
+        { role: 'system', content: SUMMARY_SYSTEM_PROMPT },
+        ...messages.map(simplifyMessageForSummary),
+      ],
+      tools: [],
+      signal: controller.signal,
+      onDelta(t) {
+        summary += t;
+      },
+    });
+    spinner.stop();
+    return summary.trim();
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+module.exports = { compactConversation, simplifyMessageForSummary };

package/src/core/config-manager.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const theme = require('../ui/theme.js');
+
+class ConfigManager {
+  constructor(options = {}) {
+    this.configDir = options.configDir || path.join(os.homedir(), '.draco');
+    this.configFile = path.join(this.configDir, 'config.json');
+    this.config = {};
+    this.watchers = new Map();
+    this.defaults = {};
+  }
+
+  setDefaults(defaults) {
+    this.defaults = { ...defaults };
+    return this;
+  }
+
+  load() {
+    try {
+      if (!fs.existsSync(this.configDir)) {
+        fs.mkdirSync(this.configDir, { recursive: true });
+      }
+
+      if (fs.existsSync(this.configFile)) {
+        const data = fs.readFileSync(this.configFile, 'utf8');
+        this.config = JSON.parse(data);
+      }
+    } catch (error) {
+      theme.printError(`Failed to load config: ${error.message}`);
+      this.config = {};
+    }
+
+    return this;
+  }
+
+  save() {
+    try {
+      if (!fs.existsSync(this.configDir)) {
+        fs.mkdirSync(this.configDir, { recursive: true });
+      }
+
+      fs.writeFileSync(this.configFile, JSON.stringify(this.config, null, 2));
+      this.notifyWatchers();
+    } catch (error) {
+      theme.printError(`Failed to save config: ${error.message}`);
+    }
+
+    return this;
+  }
+
+  get(key, defaultValue = undefined) {
+    const keys = key.split('.');
+    let value = this.config;
+
+    for (const k of keys) {
+      if (value === null || value === undefined) {
+        return this.getDefaults(key, defaultValue);
+      }
+      value = value[k];
+    }
+
+    return value !== undefined ? value : this.getDefaults(key, defaultValue);
+  }
+
+  getDefaults(key, defaultValue) {
+    const keys = key.split('.');
+    let value = this.defaults;
+
+    for (const k of keys) {
+      if (value === null || value === undefined) {
+        return defaultValue;
+      }
+      value = value[k];
+    }
+
+    return value !== undefined ? value : defaultValue;
+  }
+
+  set(key, value) {
+    const keys = key.split('.');
+    let current = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!(keys[i] in current) || typeof current[keys[i]] !== 'object') {
+        current[keys[i]] = {};
+      }
+      current = current[keys[i]];
+    }
+
+    current[keys[keys.length - 1]] = value;
+    this.save();
+
+    return this;
+  }
+
+  delete(key) {
+    const keys = key.split('.');
+    let current = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!(keys[i] in current)) return false;
+      current = current[keys[i]];
+    }
+
+    const deleted = delete current[keys[keys.length - 1]];
+    if (deleted) this.save();
+
+    return deleted;
+  }
+
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+
+  getAll() {
+    return { ...this.config };
+  }
+
+  merge(otherConfig) {
+    this.config = this.deepMerge(this.config, otherConfig);
+    this.save();
+    return this;
+  }
+
+  deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = this.deepMerge(result[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+
+    return result;
+  }
+
+  watch(key, callback) {
+    if (!this.watchers.has(key)) {
+      this.watchers.set(key, []);
+    }
+    this.watchers.get(key).push(callback);
+
+    return () => {
+      const callbacks = this.watchers.get(key);
+      if (callbacks) {
+        const index = callbacks.indexOf(callback);
+        if (index !== -1) callbacks.splice(index, 1);
+      }
+    };
+  }
+
+  notifyWatchers() {
+    for (const [key, callbacks] of this.watchers) {
+      const value = this.get(key);
+      for (const callback of callbacks) {
+        callback(value);
+      }
+    }
+  }
+
+  reset() {
+    this.config = {};
+    this.save();
+    return this;
+  }
+}
+
+module.exports = { ConfigManager };

package/src/core/fallback.js

@@ -0,0 +1,11 @@
+'use strict';
+
+function nextFallback(chain, model) {
+  if (!Array.isArray(chain)) return null;
+  const idx = chain.indexOf(model);
+  if (idx >= 0) return chain[idx + 1] || null;
+  if (chain[0] !== model) return chain[0] || null;
+  return chain[1] || null;
+}
+
+module.exports = { nextFallback };

package/src/core/images.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+
+function extractImages(workspaceRoot, text) {
+  const images = [];
+  const seen = new Set();
+  const re = /(?:[A-Za-z]:)?[^\s"']+\.(?:png|jpe?g|gif|webp)/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    try {
+      const abs = path.resolve(workspaceRoot, match[0]);
+      if (seen.has(abs)) continue;
+      const stat = fs.statSync(abs);
+      if (!stat.isFile() || stat.size > MAX_IMAGE_BYTES) continue;
+      seen.add(abs);
+      const ext = path.extname(abs).slice(1).toLowerCase();
+      const mime =
+        ext === 'jpg' || ext === 'jpeg'
+          ? 'image/jpeg'
+          : ext === 'gif'
+            ? 'image/gif'
+            : ext === 'webp'
+              ? 'image/webp'
+              : 'image/png';
+      images.push({
+        type: 'image_url',
+        image_url: { url: `data:${mime};base64,${fs.readFileSync(abs).toString('base64')}` },
+      });
+    } catch {
+      // not a readable file; leave it as plain text
+    }
+  }
+  return images;
+}
+
+module.exports = { extractImages };