dotdotdot-cli 1.0.0

package/lib/planner.js

@@ -0,0 +1,169 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// planner.js — Multi-step task orchestrator (compact, minimal output)
+// ─────────────────────────────────────────────────────────────────────────────
+
+const { bold, dim, cyan, green, red, yellow, symbols } = require('./colors');
+const { Spinner, stepLine, taskPlan, printError, printWarning, printInfo, commandBox, truncate } = require('./renderer');
+const { runCommand, copyToClipboard, stripShellWrapper } = require('./executor');
+const { selectMenu, confirm } = require('./menu');
+const { analyzeSteps } = require('./safety');
+const { queryLLM } = require('./llm');
+const { setUserIntent, addEntry } = require('./session');
+const { recordUsage, tokenLine, estimateCost } = require('./tokens');
+
+async function runTask(userInput, context, config, opts = {}) {
+  const debug = opts.debug || false;
+  // ─── Plan ─────────────────────────────────────────────────────────────
+  const spinner = new Spinner('planning...').start();
+
+  let plan;
+  try {
+    plan = await queryLLM(userInput, context, config, 'task');
+  } catch (err) {
+    spinner.fail(err.message);
+    if (err.debugLog) {
+      const { subtle } = require('./renderer');
+      process.stderr.write(`  ${subtle('log: ' + err.debugLog)}\n`);
+    }
+    process.exit(1);
+  }
+
+  if (!plan?.steps?.length) {
+    // Show the summary if the LLM explained why (e.g. "no_git is true")
+    const reason = plan?.summary || 'No steps generated. Try rephrasing.';
+    spinner.fail(reason);
+    if (plan?._debugLog) {
+      const { subtle } = require('./renderer');
+      process.stderr.write(`  ${subtle('log: ' + plan._debugLog)}\n`);
+    }
+    process.exit(1);
+  }
+
+  // Record and display token usage
+  const tokenUsage = plan._tokenUsage;
+  if (tokenUsage) {
+    recordUsage(tokenUsage, config.provider, config.model);
+  }
+
+  const steps = analyzeSteps(plan.steps);
+  const cost = estimateCost(tokenUsage, config.provider, config.model);
+  const costStr = cost ? dim(` ~$${cost}`) : '';
+  spinner.succeed(`${steps.length} steps planned | ${tokenLine(tokenUsage)}${costStr}`);
+
+  if (debug && plan._debugLog) {
+    const { subtle } = require('./renderer');
+    process.stderr.write(`  ${subtle('log: ' + plan._debugLog)}\n`);
+  }
+
+  // ─── Show plan ────────────────────────────────────────────────────────
+  if (plan.summary) printInfo(plan.summary);
+  console.log();
+  console.log(taskPlan(steps));
+
+  const hasRisk = steps.some(s => s.computedRisk === 'high');
+  if (hasRisk) printWarning('has destructive steps — will ask before those');
+
+  console.log();
+  const proceed = await selectMenu([
+    { label: 'Run', key: 'a' },
+    { label: 'Step by step', key: 's' },
+    { label: 'Copy', key: 'c' },
+    { label: 'Cancel', key: 'q' },
+  ]);
+
+  if (!proceed || proceed === 'q') { console.log(`  ${dim('cancelled')}`); return; }
+
+  if (proceed === 'c') {
+    const all = steps.map((s, i) => `# ${i+1}. ${s.description}\n${s.command}`).join('\n\n');
+    if (copyToClipboard(all)) console.log(`  ${green(symbols.check)} ${dim('copied')}`);
+    else console.log('\n' + all + '\n');
+    return;
+  }
+
+  const stepByStep = proceed === 's';
+
+  // ─── Execute ──────────────────────────────────────────────────────────
+  const states = new Array(steps.length).fill('pending'); // done, fail, skip, pending
+  let aborted = false;
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    states[i] = 'current';
+
+    // Print current step header
+    console.log();
+    console.log(stepLine(i, steps.length, step.description, 'current'));
+    if (step.command) {
+      const w = (process.stdout.columns || 80) - 12;
+      console.log(`    ${dim('$')} ${dim(truncate(step.command, w))}`);
+    }
+
+    // Only pause if: step-by-step mode, or this specific step is high-risk
+    const needsOk = stepByStep || step.computedRisk === 'high';
+
+    if (needsOk) {
+      const action = await selectMenu([
+        { label: 'Run', key: 'e' },
+        { label: 'Skip', key: 's' },
+        { label: 'Abort', key: 'q' },
+      ]);
+
+      if (!action || action === 'q') { aborted = true; states[i] = 'skip'; break; }
+      if (action === 's') { states[i] = 'skip'; continue; }
+    }
+
+    // Execute
+    setUserIntent(`${userInput} [${i+1}/${steps.length}]`);
+
+    // Safety: strip shell wrappers if the LLM accidentally added them
+    // (e.g. "powershell -Command ..." when already running in PowerShell)
+    const cmd = stripShellWrapper(step.command);
+
+    // Always show output to the user — never use captureOnly in task mode.
+    // Output is captured via the returned string regardless.
+    const { code, output } = await runCommand(cmd, config, {
+      silent: false,
+      captureOnly: false,
+    });
+
+    if (code === 0) {
+      states[i] = 'done';
+    } else {
+      states[i] = 'fail';
+
+      // In "Run" mode, auto-continue on failure (user chose to run all steps).
+      // In "Step by step" mode, ask what to do.
+      if (stepByStep) {
+        const next = await selectMenu([
+          { label: 'Continue', key: 'c' },
+          { label: 'Retry', key: 'r' },
+          { label: 'Abort', key: 'q' },
+        ]);
+        if (!next || next === 'q') { aborted = true; break; }
+        if (next === 'r') { states[i] = 'pending'; i--; continue; }
+      }
+      // In "Run" mode, just continue to next step automatically
+    }
+
+    if (step.captureOutput && output) {
+      addEntry(step.command, output, code, `step ${i+1}`);
+    }
+  }
+
+  // ─── Summary (one line) ───────────────────────────────────────────────
+  const ok = states.filter(s => s === 'done').length;
+  const fail = states.filter(s => s === 'fail').length;
+  const skip = states.filter(s => s === 'skip').length;
+
+  console.log();
+  let line = `  ${ok === steps.length ? green(symbols.check) : yellow(symbols.warning)} ${ok}/${steps.length} done`;
+  if (fail) line += `  ${red(fail + ' failed')}`;
+  if (skip) line += `  ${yellow(skip + ' skipped')}`;
+  console.log(line);
+
+  process.exit(fail > 0 ? 1 : 0);
+}
+
+module.exports = { runTask };

package/lib/postinstall.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+const G = '\x1b[32m';  // green
+const C = '\x1b[36m';  // cyan
+const D = '\x1b[2m';   // dim
+const B = '\x1b[1m';   // bold
+const W = '\x1b[97m';  // bright white
+const R = '\x1b[0m';   // reset
+
+console.log();
+console.log(`  ${G}\u2714${R} ${B}${W}dotdotdot${R} installed`);
+console.log();
+console.log(`  ${B}Get started:${R}`);
+console.log(`    ${C}... -c${R}                         ${D}Configure your API key${R}`);
+console.log(`    ${C}... list all png files${R}          ${D}Try a quick command${R}`);
+console.log(`    ${C}... find tmp files then delete${R}  ${D}Try a multi-step task${R}`);
+console.log();
+console.log(`  ${D}Zero dependencies. 5 providers. Your terminal, your way.${R}`);
+console.log();

package/lib/renderer.js

@@ -0,0 +1,145 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// renderer.js — Premium terminal UI
+// ─────────────────────────────────────────────────────────────────────────────
+
+const { bold, dim, cyan, gray, green, yellow, red, brightWhite, brightCyan,
+        stripAnsi, visibleLength, symbols, c256, rgb, bg256 } = require('./colors');
+
+const termWidth = () => Math.min(process.stdout.columns || 80, 90);
+
+// ─── Accent colors ──────────────────────────────────────────────────────────
+
+const dot1 = c256(39);   // bright blue
+const dot2 = c256(44);   // teal
+const dot3 = c256(49);   // mint
+const accent = c256(39);  // bright blue
+const subtle = c256(240); // dark gray
+const mid = c256(245);    // medium gray
+
+// ─── Truncate ───────────────────────────────────────────────────────────────
+
+function truncate(str, max) {
+  if (!str) return str;
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + '\u2026';
+}
+
+function wordWrap(str, max, indent = '  ') {
+  if (!str || str.length <= max) return indent + str;
+  const words = str.split(' ');
+  const lines = [];
+  let line = '';
+  for (const word of words) {
+    if (line && (line.length + 1 + word.length) > max) {
+      lines.push(indent + line);
+      line = word;
+    } else {
+      line = line ? line + ' ' + word : word;
+    }
+  }
+  if (line) lines.push(indent + line);
+  return lines.join('\n');
+}
+
+// ─── Command display ────────────────────────────────────────────────────────
+
+function commandBox(command, explanation, warning) {
+  const w = termWidth() - 6;
+  const out = [];
+  if (warning) out.push(`  ${yellow(symbols.warning)} ${dim(warning)}`);
+  out.push(`  ${accent('\u276F')} ${bold(brightWhite(truncate(command, w)))}`);
+  if (explanation) out.push(subtle(wordWrap(explanation, w)));
+  return out.join('\n');
+}
+
+// ─── Step line ──────────────────────────────────────────────────────────────
+
+function stepLine(i, total, label, state) {
+  const num = subtle(`${i+1}/${total}`);
+  if (state === 'done')    return `  ${green(symbols.check)} ${num} ${mid(label)}`;
+  if (state === 'current') return `  ${accent(symbols.arrowRight)} ${num} ${brightWhite(label)}`;
+  if (state === 'skip')    return `  ${yellow('-')} ${num} ${subtle(label)}`;
+  if (state === 'fail')    return `  ${red(symbols.cross)} ${num} ${subtle(label)}`;
+  return `  ${subtle('\u2500')} ${num} ${subtle(label)}`;
+}
+
+// ─── Spinner ────────────────────────────────────────────────────────────────
+
+class Spinner {
+  constructor(message = '', color = accent) {
+    this.message = message;
+    this.color = color;
+    this.frameIndex = 0;
+    this.interval = null;
+    this.stream = process.stderr;
+  }
+
+  start() {
+    if (!this.stream.isTTY) return this;
+    this.stream.write('\x1b[?25l');
+    this.interval = setInterval(() => {
+      const f = symbols.spinnerFrames[this.frameIndex];
+      this.frameIndex = (this.frameIndex + 1) % symbols.spinnerFrames.length;
+      this.stream.write(`\r\x1b[2K  ${this.color(f)} ${subtle(this.message)}`);
+    }, 80);
+    return this;
+  }
+
+  update(msg) { this.message = msg; }
+
+  succeed(msg) {
+    this._end();
+    this.stream.write(`\r\x1b[2K  ${green(symbols.check)} ${subtle(msg || this.message)}\n`);
+  }
+
+  fail(msg) {
+    this._end();
+    this.stream.write(`\r\x1b[2K  ${red(symbols.cross)} ${msg || this.message}\n`);
+  }
+
+  stop() { this._end(); this.stream.write('\r\x1b[2K'); }
+
+  _end() {
+    if (this.interval) { clearInterval(this.interval); this.interval = null; }
+    if (this.stream.isTTY) this.stream.write('\x1b[?25h');
+  }
+}
+
+// ─── Banner ─────────────────────────────────────────────────────────────────
+
+function printBanner() {
+  console.log();
+  console.log(`  ${dot1('\u25CF')} ${dot2('\u25CF')} ${dot3('\u25CF')}  ${bold(brightWhite('dotdotdot'))}`);
+}
+
+// ─── Task plan ──────────────────────────────────────────────────────────────
+
+function taskPlan(steps) {
+  const w = termWidth() - 12;
+  const lines = [];
+  for (let i = 0; i < steps.length; i++) {
+    const s = steps[i];
+    const risk = s.computedRisk === 'high' ? red('!') : s.computedRisk === 'medium' ? yellow('~') : subtle('\u2500');
+    lines.push(`  ${risk} ${subtle(`${i+1}.`)} ${truncate(s.description, w)}`);
+    if (s.command) lines.push(`    ${subtle('$')} ${subtle(truncate(s.command, w - 4))}`);
+  }
+  return lines.join('\n');
+}
+
+// ─── One-liners ─────────────────────────────────────────────────────────────
+
+function printError(msg)   { console.error(`  ${red(symbols.cross)} ${msg}`); }
+function printWarning(msg) { console.error(`  ${yellow(symbols.warning)} ${msg}`); }
+function printSuccess(msg) { console.log(`  ${green(symbols.check)} ${msg}`); }
+function printInfo(msg)    { console.log(`  ${subtle(msg)}`); }
+function keyValue(label, value, indent = 4) {
+  return `${' '.repeat(indent)}${subtle(label)} ${brightWhite(value)}`;
+}
+
+module.exports = {
+  commandBox, stepLine, Spinner, printBanner, taskPlan, truncate,
+  printError, printWarning, printSuccess, printInfo, keyValue, termWidth,
+  accent, subtle, mid, dot1, dot2, dot3,
+};

package/lib/safety.js

@@ -0,0 +1,71 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// safety.js — Command risk analysis
+// ─────────────────────────────────────────────────────────────────────────────
+
+const HIGH_RISK = [
+  // Deletion — recursive/forced only
+  { pattern: /\brm\s+(-[a-z]*r|-[a-z]*f|--recursive|--force)/i, reason: 'Recursive/forced deletion' },
+  { pattern: /\bRemove-Item\b.*(-Recurse|-Force)/i, reason: 'Recursive/forced deletion' },
+  { pattern: /\bdel\s+\/[sS]/i, reason: 'Recursive deletion' },
+  { pattern: /\brm\s+-rf\s+[\/~]/i, reason: 'Deleting from root or home' },
+
+  // System-level — only actual disk format commands, not PowerShell Format-*
+  { pattern: /\bformat\s+[a-zA-Z]:/i, reason: 'Disk formatting' },
+  { pattern: /\bmkfs\b/i, reason: 'Filesystem creation' },
+  { pattern: /\bdd\s+if=/i, reason: 'Low-level disk write' },
+  { pattern: /\bchmod\s+777/i, reason: 'Insecure permissions' },
+
+  // Dangerous pipes
+  { pattern: /\bcurl\b.*\|\s*(bash|sh|zsh)/i, reason: 'Download and execute' },
+
+  // Elevated
+  { pattern: /\bsudo\b/i, reason: 'Elevated privileges' },
+  { pattern: /\brunas\b/i, reason: 'Elevated privileges' },
+  { pattern: /Set-ExecutionPolicy\s+Unrestricted/i, reason: 'Weakening execution policy' },
+
+  // Registry
+  { pattern: /\breg\s+delete\b/i, reason: 'Registry deletion' },
+  { pattern: /Remove-ItemProperty.*HKLM/i, reason: 'System registry modification' },
+
+  // Firewall
+  { pattern: /\biptables\b/i, reason: 'Firewall modification' },
+];
+
+const MEDIUM_RISK = [
+  { pattern: /\brm\b(?!.*Format)/i, reason: 'File deletion' },
+  { pattern: /\bRemove-Item\b(?!Property)/i, reason: 'File deletion' },
+  { pattern: /\bMove-Item\b|\bmv\b/i, reason: 'Moving files' },
+  { pattern: /\bkill\b|\bStop-Process\b|\btaskkill\b/i, reason: 'Process termination' },
+  { pattern: /\bnpm\s+(install|uninstall)\s+-g/i, reason: 'Global package change' },
+  { pattern: /\bgit\s+(push|reset\s+--hard|rebase|force)/i, reason: 'Git history change' },
+  { pattern: /\bdocker\s+(rm|rmi|stop|kill|prune)/i, reason: 'Docker resource removal' },
+];
+
+function analyzeRisk(command) {
+  if (!command) return { level: 'low', reasons: [] };
+
+  for (const { pattern, reason } of HIGH_RISK) {
+    if (pattern.test(command)) return { level: 'high', reasons: [reason] };
+  }
+  for (const { pattern, reason } of MEDIUM_RISK) {
+    if (pattern.test(command)) return { level: 'medium', reasons: [reason] };
+  }
+  return { level: 'low', reasons: [] };
+}
+
+function analyzeSteps(steps) {
+  return steps.map(step => {
+    const risk = analyzeRisk(step.command);
+    return {
+      ...step,
+      computedRisk: risk.level,
+      riskReasons: risk.reasons,
+      // Only force approval on actually dangerous steps
+      needsApproval: step.needsApproval || risk.level === 'high',
+    };
+  });
+}
+
+module.exports = { analyzeRisk, analyzeSteps };

package/lib/session.js

@@ -0,0 +1,165 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// session.js — Session history for conversational follow-ups & multi-step tasks
+// ─────────────────────────────────────────────────────────────────────────────
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const SESSION_FILE = path.join(os.tmpdir(), 'dotdotdot-session.json');
+const MAX_ENTRIES  = 20;
+const SESSION_TTL  = 30 * 60 * 1000; // 30 minutes
+const MAX_OUTPUT   = 2000; // max chars of output to store (reduced from 4000)
+
+// Terminal session ID — detect new shell sessions to clear stale context.
+// Uses parent PID + shell PID as a fingerprint. New terminal = new session.
+function getTerminalSessionId() {
+  try {
+    return `${process.ppid || 0}`;
+  } catch { return '0'; }
+}
+
+// ─── Load session ───────────────────────────────────────────────────────────
+
+function loadSession() {
+  const empty = { entries: [], previousSummary: null, taskId: null, taskSteps: null, terminalId: null };
+  try {
+    const raw = fs.readFileSync(SESSION_FILE, 'utf8');
+    const session = JSON.parse(raw);
+    
+    // Guard against malformed/old session files
+    if (!session || !Array.isArray(session.entries)) {
+      return empty;
+    }
+
+    // Clear on new terminal session — user unlikely wants old context
+    const currentTerminal = getTerminalSessionId();
+    if (session.terminalId && session.terminalId !== currentTerminal) {
+      return { ...empty, terminalId: currentTerminal };
+    }
+
+    // Check timeout
+    if (session.entries.length > 0) {
+      const lastTime = session.entries[session.entries.length - 1].time;
+      if (Date.now() - lastTime > SESSION_TTL) {
+        return { ...empty, terminalId: currentTerminal };
+      }
+    }
+    
+    return { ...empty, ...session, entries: session.entries, terminalId: currentTerminal };
+  } catch {
+    return empty;
+  }
+}
+
+// ─── Save session ───────────────────────────────────────────────────────────
+
+function saveSession(session) {
+  try {
+    // Trim entries
+    if (session.entries.length > MAX_ENTRIES) {
+      session.entries = session.entries.slice(-MAX_ENTRIES);
+    }
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(session));
+  } catch { /* ignore write errors */ }
+}
+
+// ─── Add entry ──────────────────────────────────────────────────────────────
+
+function addEntry(command, output, exitCode, intent) {
+  const session = loadSession();
+  session.entries.push({
+    command,
+    output: output ? output.slice(0, MAX_OUTPUT) : '',
+    exitCode,
+    intent: intent || '',
+    time: Date.now(),
+  });
+  saveSession(session);
+  return session;
+}
+
+// ─── Get session history formatted for LLM ──────────────────────────────────
+
+function getHistory() {
+  const session = loadSession();
+  if (!session.entries.length) return null;
+
+  // Return compact array — only last 5 entries, minimal data
+  const compact = session.entries.slice(-5).map(e => {
+    const h = { cmd: e.command, ok: e.exitCode === 0 };
+    if (e.intent) h.q = e.intent;
+    // Include output snippet — follow-ups need prior output (e.g. "delete those files")
+    if (e.output) {
+      const maxOut = e.exitCode !== 0 ? 300 : 300;
+      h.out = e.output.length > maxOut ? e.output.slice(0, maxOut) + '…' : e.output;
+    }
+    return h;
+  });
+
+  return compact;
+}
+
+// ─── Task state management (for multi-step tasks) ───────────────────────────
+
+function setTaskState(taskId, steps, currentStep) {
+  const session = loadSession();
+  session.taskId = taskId;
+  session.taskSteps = steps;
+  session.taskCurrentStep = currentStep || 0;
+  saveSession(session);
+}
+
+function getTaskState() {
+  const session = loadSession();
+  return {
+    taskId: session.taskId,
+    steps: session.taskSteps,
+    currentStep: session.taskCurrentStep || 0,
+  };
+}
+
+function clearTaskState() {
+  const session = loadSession();
+  session.taskId = null;
+  session.taskSteps = null;
+  session.taskCurrentStep = 0;
+  saveSession(session);
+}
+
+// ─── Set user intent for next entry ─────────────────────────────────────────
+
+let _pendingIntent = '';
+
+function setUserIntent(intent) {
+  _pendingIntent = intent;
+}
+
+function getUserIntent() {
+  const i = _pendingIntent;
+  _pendingIntent = '';
+  return i;
+}
+
+// ─── Clear entire session ───────────────────────────────────────────────────
+
+function clearSession() {
+  try {
+    fs.unlinkSync(SESSION_FILE);
+  } catch { /* ignore if already gone */ }
+}
+
+module.exports = {
+  loadSession,
+  saveSession,
+  addEntry,
+  getHistory,
+  setTaskState,
+  getTaskState,
+  clearTaskState,
+  clearSession,
+  setUserIntent,
+  getUserIntent,
+};