draco-cli 0.0.0-stage → 3.0.2

package/src/core/session.js

@@ -0,0 +1,307 @@
+'use strict';
+
+const { AbortedError, isFallbackable, streamChatCompletion } = require('../providers/openai-compatible.js');
+const { buildToolDefs, executeTool } = require('../tools/index.js');
+const { MarkdownStream } = require('../ui/markdown.js');
+const { buildSystemPrompt, loadAgentsMd } = require('./prompt.js');
+const { nextFallback } = require('./fallback.js');
+const { extractImages } = require('./images.js');
+const { compactConversation } = require('./compaction.js');
+const { saveSession } = require('./sessions-store.js');
+const ui = require('../ui/terminal.js');
+
+const MAX_TOOL_ROUNDS = 12;
+const MAX_TOOL_RESULT_CHARS = 16000;
+
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + `\n[...truncated ${text.length - max} chars...]`;
+}
+
+function buildUserMessage(workspaceRoot, text) {
+  const images = extractImages(workspaceRoot, text);
+  if (images.length === 0) return { role: 'user', content: text };
+  return { role: 'user', content: [{ type: 'text', text }, ...images] };
+}
+
+function createSession(cfg, ask, options) {
+  const opts = options || {};
+  const mcp = opts.mcp || null;
+  const agentsMd = loadAgentsMd(cfg.workspaceRoot);
+
+  const state = {
+    cfg,
+    ask,
+    activeModel: cfg.model,
+    lastUserText: null,
+    messages: [],
+    activeController: null,
+    usage: { turns: 0, outputChars: 0 },
+  };
+
+  function abortActive() {
+    if (state.activeController) {
+      state.activeController.abort();
+      return true;
+    }
+    return false;
+  }
+
+  function reset() {
+    state.messages = [{ role: 'system', content: buildSystemPrompt(cfg, agentsMd) }];
+  }
+
+  function toolContext() {
+    return {
+      workspaceRoot: cfg.workspaceRoot,
+      yolo: cfg.yolo,
+      approvals: cfg.approvals,
+      ask: state.ask,
+      cfg,
+      mcp,
+    };
+  }
+
+  async function runTurn(userText) {
+    state.lastUserText = userText;
+    state.messages.push(buildUserMessage(cfg.workspaceRoot, userText));
+    await completeTurn();
+    state.usage.turns += 1;
+    persist();
+  }
+
+  async function retry() {
+    if (!state.lastUserText) {
+      ui.warn('Nothing to retry yet.');
+      return false;
+    }
+    const last = state.messages[state.messages.length - 1];
+    if (!last || last.role !== 'user') {
+      state.messages.push(buildUserMessage(cfg.workspaceRoot, state.lastUserText));
+    }
+    ui.info(`Retrying: "${truncate(String(state.lastUserText), 60)}"`);
+    await completeTurn();
+    persist();
+    return true;
+  }
+
+  async function compact() {
+    const conversation = state.messages.filter((m) => m.role !== 'system');
+    if (conversation.length < 3) {
+      ui.warn('Conversation is too short to compact.');
+      return false;
+    }
+    let summary;
+    try {
+      summary = await compactConversation({
+        cfg,
+        model: state.activeModel,
+        messages: conversation,
+      });
+    } catch (err) {
+      ui.error(`Compaction failed: ${err.message || err}`);
+      return false;
+    }
+    if (!summary) {
+      ui.error('Compaction produced an empty summary; conversation left unchanged.');
+      return false;
+    }
+    state.messages = [
+      { role: 'system', content: buildSystemPrompt(cfg, agentsMd) },
+      {
+        role: 'user',
+        content: `[Earlier conversation was summarized to stay within context limits. Summary:]\n${summary}\n\n[End of summary. Continue helping from here.]`,
+      },
+    ];
+    persist();
+    ui.success(`Conversation compacted to ~${Math.round(summary.length / 4)} tokens of summary.`);
+    return true;
+  }
+
+  function persist() {
+    saveSession(cfg.workspaceRoot, exportSession());
+  }
+
+  function exportSession() {
+    return {
+      version: 2,
+      cwd: cfg.workspaceRoot,
+      model: state.activeModel,
+      updatedAt: new Date().toISOString(),
+      lastUserText: state.lastUserText,
+      messages: state.messages,
+    };
+  }
+
+  function importSession(data) {
+    if (
+      !data ||
+      !Array.isArray(data.messages) ||
+      data.messages.length === 0 ||
+      data.messages[0].role !== 'system'
+    ) {
+      return false;
+    }
+    state.messages = data.messages;
+    if (typeof data.model === 'string' && data.model) {
+      state.activeModel = data.model;
+      cfg.model = data.model;
+    }
+    state.lastUserText = typeof data.lastUserText === 'string' ? data.lastUserText : null;
+    return true;
+  }
+
+  function getUsage() {
+    return {
+      ...state.usage,
+      messages: state.messages.filter((m) => m.role !== 'system').length,
+    };
+  }
+
+  async function completeTurn() {
+    const md = new MarkdownStream();
+    for (let round = 1; ; round++) {
+      if (round > MAX_TOOL_ROUNDS) {
+        ui.error(`Stopped after ${MAX_TOOL_ROUNDS} tool rounds in a single turn.`);
+        return;
+      }
+      const model = state.activeModel;
+      const controller = new AbortController();
+      state.activeController = controller;
+      const spinner = new ui.Spinner(`Thinking (${model})…`);
+      spinner.start();
+      let acc = '';
+      let emitted = false;
+      let res;
+      try {
+        res = await streamChatCompletion({
+          cfg,
+          model,
+          messages: state.messages,
+          tools: buildToolDefs(mcp ? mcp.listTools() : []),
+          signal: controller.signal,
+          onDelta(t) {
+            acc += t;
+            if (!emitted) {
+              emitted = true;
+              spinner.stop();
+            }
+            md.write(t);
+          },
+        });
+      } catch (err) {
+        state.activeController = null;
+        spinner.stop();
+        if (err instanceof AbortedError || controller.signal.aborted) {
+          md.end();
+          if (emitted) process.stdout.write('\n');
+          ui.warn('⏹ Response stopped. Type /retry to resend your last message.');
+          return;
+        }
+        if (isFallbackable(err) && !emitted) {
+          const nextModel = nextFallback(cfg.fallbackChain, model);
+          if (nextModel) {
+            ui.warn(
+              `Switching to backup model: ${nextModel} — ${model} hit ${
+                err.status === 429 ? 'a rate limit' : 'an availability error'
+              }.`
+            );
+            state.activeModel = nextModel;
+            continue;
+          }
+          ui.error(
+            `All models in the fallback chain failed. Use /models to pick another manually.`
+          );
+          return;
+        }
+        if (emitted) {
+          md.end();
+          process.stdout.write('\n');
+          ui.error('Connection dropped mid-stream. Type /retry to resend your last message.');
+          return;
+        }
+        if (err instanceof AbortedError) {
+          ui.warn(err.message);
+          return;
+        }
+        if (err instanceof Error && err.name === 'AbortError') {
+          ui.error('Request timed out — connection may have dropped.');
+          return;
+        }
+        ui.error(`${err.status ? `API error HTTP ${err.status}: ` : ''}${err.message || err}`);
+        return;
+      }
+      if (emitted) {
+        md.end();
+        process.stdout.write('\n');
+      }
+      state.usage.outputChars += acc.length;
+
+      const toolCalls = res.toolCalls || [];
+      if (toolCalls.length > 0) {
+        state.messages.push({
+          role: 'assistant',
+          content: acc || null,
+          tool_calls: toolCalls.map((tc) => ({
+            id: tc.id,
+            type: 'function',
+            function: { name: tc.function.name, arguments: tc.function.arguments },
+          })),
+        });
+        for (const tc of toolCalls) {
+          if (controller.signal.aborted) {
+            state.activeController = null;
+            ui.warn('⏹ Response stopped. Type /retry to resend your last message.');
+            return;
+          }
+          let args = {};
+          try {
+            args = JSON.parse(tc.function.arguments || '{}');
+          } catch {
+            args = { _raw: tc.function.arguments };
+          }
+          ui.toolStart(tc.function.name, args);
+          const result = await executeTool(tc.function.name, args, toolContext());
+          state.messages.push({
+            role: 'tool',
+            tool_call_id: tc.id,
+            content: truncate(String(result), MAX_TOOL_RESULT_CHARS),
+          });
+        }
+        continue;
+      }
+
+      state.activeController = null;
+      state.messages.push({ role: 'assistant', content: acc });
+      if (!acc && res.finishReason !== 'stop') {
+        ui.error('(empty response from model)');
+      }
+      return;
+    }
+  }
+
+  function setModel(id) {
+    state.activeModel = id;
+    cfg.model = id;
+  }
+
+  reset();
+
+  return {
+    get activeModel() {
+      return state.activeModel;
+    },
+    setModel,
+    reset,
+    retry,
+    compact,
+    runTurn,
+    abortActive,
+    exportSession,
+    importSession,
+    clearSavedSession: () => require('./sessions-store.js').clearSavedSession(cfg.workspaceRoot),
+    getUsage,
+  };
+}
+
+module.exports = { createSession };

package/src/core/sessions-store.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const config = require('../config.js');
+
+function saveSession(workspaceRoot, data) {
+  try {
+    const file = config.sessionFileFor(workspaceRoot);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data));
+    return file;
+  } catch {
+    return null;
+  }
+}
+
+function loadLatestSession(workspaceRoot) {
+  try {
+    const file = config.sessionFileFor(workspaceRoot);
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function clearSavedSession(workspaceRoot) {
+  try {
+    fs.unlinkSync(config.sessionFileFor(workspaceRoot));
+  } catch {}
+}
+
+function listSessions() {
+  const dir = config.sessionsDir();
+  let files = [];
+  try {
+    files = fs
+      .readdirSync(dir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => path.join(dir, f));
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (!data || !Array.isArray(data.messages)) continue;
+      sessions.push({ file, data });
+    } catch {}
+  }
+  sessions.sort((a, b) => String(b.data.updatedAt).localeCompare(String(a.data.updatedAt)));
+  return sessions;
+}
+
+module.exports = { saveSession, loadLatestSession, clearSavedSession, listSessions };

package/src/index.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const readline = require('readline');
+
+const config = require('./config.js');
+const ui = require('./ui/terminal.js');
+const mcpClient = require('./integrations/mcp-manager.js');
+const { createSession } = require('./core/session.js');
+const { loadLatestSession } = require('./core/sessions-store.js');
+const { parseArgs } = require('./cli/args.js');
+const { createLineQueue } = require('./cli/line-queue.js');
+const { runRepl } = require('./cli/repl.js');
+const { runOneShot } = require('./cli/oneshot.js');
+
+function printUsage() {
+  process.stdout.write(
+    [
+      `Draco CLI v${config.VERSION}`,
+      '',
+      'Usage: draco [prompt] [options]',
+      '',
+      'Options:',
+      '  --model=<id>    Start with a specific model id',
+      '  --suggest       Ask before every file write and shell command',
+      '  --auto-edit     Auto-apply file edits, still ask before shell commands',
+      '  --full-auto     Run everything without asking (same as --yolo)',
+      '  --yolo          Alias of --full-auto',
+      '  --continue, -c  Resume the last session for this directory',
+      '  --version, -v   Print version and exit',
+      '  --help, -h      Show this help',
+      '  --check-update  Check for available updates',
+      '',
+      'One-shot mode:   draco "your prompt here" — answer once, then exit',
+      '',
+      'Environment:',
+      '  OPENCODE_ZEN_KEY        Optional. Skips the first-run key prompt.',
+      '  DRACO_MODEL             Default model override (default: nemotron-3-ultra-free)',
+      '  DRACO_APPROVALS         suggest | auto-edit | full-auto',
+      '  DRACO_YOLO              "true" to auto-approve shell commands',
+      '  DRACO_API_BASE          Override the API endpoint',
+      '  DRACO_SEARCH_PROVIDER   Search backend when a key is set (default: brave)',
+      '  DRACO_SEARCH_API_KEY    Optional. Use Brave instead of built-in DuckDuckGo',
+    ].join('\n') + '\n'
+  );
+}
+
+function installGlobalHandlers() {
+  process.on('uncaughtException', (err) => {
+    ui.error(`Uncaught exception: ${err && err.stack ? err.stack : err}`);
+  });
+  process.on('unhandledRejection', (reason) => {
+    ui.error(`Unhandled rejection: ${reason instanceof Error ? reason.stack : String(reason)}`);
+  });
+}
+
+async function ensureApiKey(cfg, nextLine) {
+  if (cfg.apiKey) return true;
+  ui.info('No API key found. Get a free one at https://opencode.ai');
+  for (let attempt = 0; attempt < 5; attempt++) {
+    process.stdout.write(`${ui.c.yellow}?${ui.c.reset} Enter your OpenCode Zen API key: `);
+    const line = await nextLine();
+    if (line === null) return false;
+    const key = line.trim();
+    if (!key) {
+      ui.error('Key cannot be empty.');
+      continue;
+    }
+    const spinner = new ui.Spinner('Validating key…');
+    spinner.start();
+    const probe = await api_probe(cfg, key);
+    spinner.stop();
+    if (probe.verdict === 'invalid') {
+      ui.error(`Key rejected (HTTP ${probe.status}). Check it and try again.`);
+      continue;
+    }
+    if (probe.verdict === 'unreachable') {
+      ui.error(`Could not reach the API to verify (${probe.detail}). Using the key anyway.`);
+    }
+    cfg.apiKey = key;
+    cfg.keySource = 'session';
+    break;
+  }
+  if (!cfg.apiKey) return false;
+  process.stdout.write(
+    `${ui.c.yellow}?${ui.c.reset} Save key to ${cfg.configFile} for future sessions? [Y/n] `
+  );
+  const saveAnswer = await nextLine();
+  const declined =
+    saveAnswer !== null && ['n', 'no'].includes(saveAnswer.trim().toLowerCase());
+  if (declined) {
+    ui.info('Key kept for this session only.');
+  } else {
+    try {
+      config.persistConfig({ apiKey: cfg.apiKey });
+      cfg.keySource = 'saved';
+      ui.success(`Key saved to ${cfg.configFile}.`);
+    } catch (e) {
+      ui.error(`Could not save key (${e.message}). It will only last this session.`);
+    }
+  }
+  return true;
+}
+
+async function checkForUpdate() {
+  const https = require('https');
+  const currentVersion = config.VERSION;
+  
+  return new Promise((resolve) => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      path: '/draco-cli/latest',
+      method: 'GET',
+      timeout: 5000,
+    };
+    
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const pkg = JSON.parse(data);
+          const latestVersion = pkg.version;
+          if (latestVersion !== currentVersion) {
+            resolve({
+              updateAvailable: true,
+              current: currentVersion,
+              latest: latestVersion,
+            });
+          } else {
+            resolve({ updateAvailable: false, current: currentVersion });
+          }
+        } catch (e) {
+          resolve({ updateAvailable: false, current: currentVersion, error: e.message });
+        }
+      });
+    });
+    
+    req.on('error', () => {
+      resolve({ updateAvailable: false, current: currentVersion, error: 'Could not check for updates' });
+    });
+    
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ updateAvailable: false, current: currentVersion, error: 'Timeout checking for updates' });
+    });
+    
+    req.end();
+  });
+}
+
+function api_probe(cfg, key) {
+  const { probeApiKey } = require('./providers/openai-compatible.js');
+  return probeApiKey(cfg, key);
+}
+
+async function main(argv) {
+  let flags;
+  try {
+    flags = parseArgs(argv || []);
+  } catch (e) {
+    ui.error(e.message);
+    printUsage();
+    process.exit(2);
+  }
+
+  config.loadEnvFile();
+  if (flags.version) {
+    process.stdout.write(`Draco CLI v${config.VERSION}\n`);
+    return;
+  }
+  if (flags.help) {
+    printUsage();
+    return;
+  }
+  
+  if (flags.checkUpdate) {
+    const result = await checkForUpdate();
+    if (result.updateAvailable) {
+      ui.info(`Update available: ${result.current} -> ${result.latest}`);
+      ui.info('Run "npm update -g draco-cli" to update.');
+    } else {
+      ui.success(`You are running the latest version (${result.current}).`);
+    }
+    return;
+  }
+
+  const cfg = config.resolveConfig(flags);
+  ui.splash(cfg);
+
+  installGlobalHandlers();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: Boolean(process.stdin.isTTY),
+  });
+  const lineQueue = createLineQueue(rl);
+  const nextLine = lineQueue.nextLine;
+
+  rl.on('SIGINT', () => {
+    process.stdout.write('\n');
+    ui.info('Goodbye.');
+    process.exit(0);
+  });
+
+  const hasKey = await ensureApiKey(cfg, nextLine);
+  if (!hasKey) {
+    ui.error('No API key provided. Set OPENCODE_ZEN_KEY or enter it when prompted.');
+    process.exit(1);
+  }
+
+  const mcp = await mcpClient.createFromConfig();
+
+  const agent = createSession(
+    cfg,
+    async (question) => {
+      process.stdout.write(`${ui.c.yellow}?${ui.c.reset} ${question}`);
+      const answer = await nextLine();
+      return answer === null ? '' : answer;
+    },
+    { mcp }
+  );
+
+  rl.on('keypress', (_ch, key) => {
+    if (key && key.name === 'escape') {
+      agent.abortActive();
+    }
+  });
+
+  if (flags.continueSession) {
+    const data = loadLatestSession(cfg.workspaceRoot);
+    if (data && agent.importSession(data)) ui.success(`Resumed last session (${data.model}).`);
+    else ui.info('No previous session for this directory — starting fresh.');
+  }
+
+  if (flags.promptArgs && flags.promptArgs.length > 0) {
+    const prompt = flags.promptArgs.join(' ').trim();
+    const code = await runOneShot({ prompt, agent });
+    try {
+      rl.close();
+    } catch {}
+    mcp.stopAll();
+    setTimeout(() => process.exit(code), 300);
+    return;
+  }
+
+  await runRepl({ cfg, rl, lineQueue, agent, mcp });
+
+  try {
+    mcp.stopAll();
+  } catch {}
+  setTimeout(() => process.exit(0), 250).unref();
+}
+
+module.exports = { main };