markov-cli 1.0.0

package/bin/markov.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const { startInteractive } = await import('../src/interactive.js');
+startInteractive();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "markov-cli",
+  "version": "1.0.0",
+  "description": "A friendly CLI tool",
+  "type": "module",
+  "bin": {
+    "markov-cli": "./bin/markov.js"
+  },
+  "scripts": {
+    "start": "node bin/markov-cli.js"
+  },
+  "keywords": [
+    "cli",
+    "markov",
+    "markov-cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "bin",
+    "src",
+    ".env.example"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^16.4.5",
+    "gradient-string": "^3.0.0"
+  }
+}

package/src/auth.js

@@ -0,0 +1,35 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CONFIG_DIR = join(homedir(), '.markov');
+const TOKEN_PATH = join(CONFIG_DIR, 'token');
+
+export const API_URL = 'https://api.livingcloud.app/api';
+
+export function getToken() {
+  if (!existsSync(TOKEN_PATH)) return null;
+  return readFileSync(TOKEN_PATH, 'utf-8').trim() || null;
+}
+
+export function saveToken(token) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(TOKEN_PATH, token, 'utf-8');
+}
+
+export async function login(email, password) {
+  const res = await fetch(`${API_URL}/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`Login failed (${res.status})${body ? ': ' + body : ''}`);
+  }
+  const data = await res.json();
+  const token = data.data?.token ?? data.token ?? data.accessToken ?? data.access_token;
+  if (!token) throw new Error('No token received from server');
+  saveToken(token);
+  return token;
+}

package/src/editor.js

@@ -0,0 +1,173 @@
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { join, extname } from 'path';
+import chalk from 'chalk';
+
+// Maps common language identifiers (including short aliases) to file extensions.
+const LANG_TO_EXT = {
+  typescript: ['.ts', '.tsx'],
+  ts:         ['.ts', '.tsx'],
+  tsx:        ['.tsx'],
+  javascript: ['.js', '.jsx', '.mjs', '.cjs'],
+  js:         ['.js', '.jsx', '.mjs', '.cjs'],
+  jsx:        ['.jsx'],
+  python:     ['.py'],
+  py:         ['.py'],
+  css:        ['.css'],
+  scss:       ['.scss'],
+  html:       ['.html'],
+  json:       ['.json'],
+  bash:       ['.sh'],
+  sh:         ['.sh'],
+  markdown:   ['.md'],
+  md:         ['.md'],
+};
+
+// --- Diff engine (LCS-based) ---
+
+function lcs(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Uint32Array(n + 1));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = a[i-1] === b[j-1] ? dp[i-1][j-1] + 1 : Math.max(dp[i-1][j], dp[i][j-1]);
+
+  const result = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && a[i-1] === b[j-1]) {
+      result.unshift({ type: 'equal', line: a[i-1] }); i--; j--;
+    } else if (j > 0 && (i === 0 || dp[i][j-1] >= dp[i-1][j])) {
+      result.unshift({ type: 'add', line: b[j-1] }); j--;
+    } else {
+      result.unshift({ type: 'del', line: a[i-1] }); i--;
+    }
+  }
+  return result;
+}
+
+const CONTEXT = 3; // unchanged lines to show around each change
+
+function buildHunks(diff) {
+  // Mark which equal lines are within CONTEXT of a change
+  const changed = diff.map(d => d.type !== 'equal');
+  const show    = diff.map((_, i) => {
+    if (changed[i]) return true;
+    for (let d = 1; d <= CONTEXT; d++)
+      if (changed[i - d] || changed[i + d]) return true;
+    return false;
+  });
+
+  const hunks = [];
+  let hunk = null;
+  for (let i = 0; i < diff.length; i++) {
+    if (!show[i]) {
+      if (hunk) { hunks.push(hunk); hunk = null; }
+      continue;
+    }
+    if (!hunk) hunk = [];
+    hunk.push(diff[i]);
+  }
+  if (hunk) hunks.push(hunk);
+  return hunks;
+}
+
+/**
+ * Renders a colour diff to stdout and returns { added, removed } counts.
+ */
+export function renderDiff(filepath, newContent, cwd = process.cwd()) {
+  const fullPath = join(cwd, filepath);
+  const oldContent = existsSync(fullPath) ? readFileSync(fullPath, 'utf-8') : '';
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+
+  const diff  = lcs(oldLines, newLines);
+  const hunks = buildHunks(diff);
+
+  const w = process.stdout.columns || 80;
+  const header = ` ✏  ${filepath} `;
+  const pad = Math.max(0, w - header.length);
+  const lpad = Math.floor(pad / 2);
+  const rpad = pad - lpad;
+
+  console.log('\n' + chalk.dim('─'.repeat(lpad)) + chalk.bold.white(header) + chalk.dim('─'.repeat(rpad)));
+
+  let added = 0, removed = 0;
+  let oldLine = 1, newLine = 1;
+
+  // Recalculate line numbers
+  const lineNums = [];
+  { let o = 1, n = 1;
+    for (const d of diff) {
+      if (d.type === 'equal') { lineNums.push({ o, n }); o++; n++; }
+      else if (d.type === 'del') { lineNums.push({ o, n: null }); o++; }
+      else { lineNums.push({ o: null, n }); n++; }
+    }
+  }
+
+  let diffIdx = 0;
+  for (const hunk of hunks) {
+    // Find start in full diff
+    const startIdx = diff.indexOf(hunk[0]);
+    const sep = chalk.dim('@@ ' + '─'.repeat(w - 4));
+    if (hunks.indexOf(hunk) > 0) console.log(sep);
+
+    for (let k = 0; k < hunk.length; k++) {
+      const d   = hunk[k];
+      const idx = startIdx + k;
+      const ln  = lineNums[idx];
+      const num = String(ln.n ?? ln.o).padStart(4);
+
+      if (d.type === 'equal') {
+        console.log(chalk.dim(`${num}   ${d.line}`));
+      } else if (d.type === 'del') {
+        console.log(chalk.red(`${num} - ${d.line}`));
+        removed++;
+      } else {
+        console.log(chalk.green(`${num} + ${d.line}`));
+        added++;
+      }
+    }
+  }
+
+  if (hunks.length === 0) console.log(chalk.dim('  (no changes)'));
+
+  const summary = chalk.green(`+${added}`) + chalk.dim(' / ') + chalk.red(`-${removed}`);
+  console.log(chalk.dim('─'.repeat(w)) + '\n' + '  ' + summary + '\n');
+
+  return { added, removed, oldContent };
+}
+
+// --- Parse & apply ---
+
+export function parseEdits(responseText, loadedFiles = []) {
+  const edits = [];
+  const regex = /```([\w./\-]*)\n([\s\S]*?)```/g;
+  let match;
+
+  while ((match = regex.exec(responseText)) !== null) {
+    const tag     = match[1].trim();
+    const content = match[2];
+
+    if (tag && (tag.includes('.') || tag.includes('/'))) {
+      const exact = loadedFiles.find(f => f === tag || f.endsWith('/' + tag));
+      edits.push({ filepath: exact || tag, content });
+      continue;
+    }
+
+    if (tag) {
+      const exts    = LANG_TO_EXT[tag.toLowerCase()] || [];
+      const matched = loadedFiles.find(f => exts.includes(extname(f).toLowerCase()));
+      if (matched) { edits.push({ filepath: matched, content }); continue; }
+    }
+
+    if (loadedFiles.length === 1) {
+      edits.push({ filepath: loadedFiles[0], content });
+    }
+  }
+
+  return edits;
+}
+
+export function applyEdit(filepath, content, cwd = process.cwd()) {
+  writeFileSync(join(cwd, filepath), content, 'utf-8');
+}

package/src/files.js

@@ -0,0 +1,54 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const FILE_REF_REGEX = /@([\w./\-]+)/g;
+
+/**
+ * Finds all @ref patterns in a string and returns the unique file paths.
+ */
+export function parseFileRefs(input) {
+  const refs = [];
+  let match;
+  const regex = new RegExp(FILE_REF_REGEX.source, 'g');
+  while ((match = regex.exec(input)) !== null) {
+    if (!refs.includes(match[1])) refs.push(match[1]);
+  }
+  return refs;
+}
+
+/**
+ * Reads each @ref file from cwd, returns { content, loaded, failed }.
+ * `content` is the enriched message with file contents prepended.
+ */
+export function resolveFileRefs(input, cwd = process.cwd()) {
+  const refs = parseFileRefs(input);
+  if (refs.length === 0) return { content: input, loaded: [], failed: [] };
+
+  const loaded = [];
+  const failed = [];
+  const blocks = [];
+
+  for (const ref of refs) {
+    const fullPath = join(cwd, ref);
+    if (!existsSync(fullPath)) {
+      failed.push(ref);
+      continue;
+    }
+    try {
+      const text = readFileSync(fullPath, 'utf-8');
+      blocks.push(`--- @${ref} ---\n${text}\n---`);
+      loaded.push(ref);
+    } catch {
+      failed.push(ref);
+    }
+  }
+
+  const contextBlock = blocks.length > 0
+    ? `The user referenced the following file(s) as context:\n\n${blocks.join('\n\n')}\n\n` +
+      `If you need to edit a file, output the complete new file content in a fenced code block tagged with the EXACT filename, like:\n` +
+      `${loaded.map(f => `\`\`\`${f}\n// full new content\n\`\`\``).join('\n')}\n\n` +
+      `IMPORTANT: Use the exact filename shown above as the code block tag, not the language name.\n\n`
+    : '';
+
+  return { content: contextBlock + input, loaded, failed };
+}

package/src/input.js

@@ -0,0 +1,194 @@
+import chalk from 'chalk';
+import { filterFiles } from './ui/picker.js';
+import { MODEL } from './ollama.js';
+
+// Strip ANSI escape codes to get the true visible length of a string.
+const visibleLen = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').length;
+
+const PREFIX      = '❯  ';
+const HINT        = chalk.dim(' Ask Markov anything...');
+const STATUS_LEFT = chalk.dim('ctrl+q cancel  ·  @ attach files  ·  /cd change dir  ·  /models switch model  ·  /login auth');
+const PICKER_MAX  = 6;
+
+function border() {
+  return chalk.dim('─'.repeat(process.stdout.columns || 80));
+}
+
+function statusBar() {
+  const right = chalk.dim(`Markov (${MODEL})`);
+  const w   = process.stdout.columns || 80;
+  const gap = Math.max(1, w - visibleLen(STATUS_LEFT) - visibleLen(right));
+  return STATUS_LEFT + ' '.repeat(gap) + right;
+}
+
+/**
+ * Show an interactive raw-mode prompt that supports @file autocomplete.
+ * Returns a Promise<string|null> — null means the prompt was cancelled (Ctrl+Q).
+ */
+export function chatPrompt(_promptStr, allFiles) {
+  return new Promise((resolve) => {
+    const stdin  = process.stdin;
+    const stdout = process.stdout;
+
+    let buffer      = '';
+    let pickerFiles = [];
+    let pickerIndex = 0;
+    let cursorLineOffset = 0; // lines from top of drawn block to where cursor sits
+
+    const getAtPos = () => {
+      for (let i = buffer.length - 1; i >= 0; i--) {
+        if (buffer[i] === ' ') return -1;
+        if (buffer[i] === '@') return i;
+      }
+      return -1;
+    };
+
+    const updatePicker = () => {
+      const atPos = getAtPos();
+      if (atPos === -1) { pickerFiles = []; pickerIndex = 0; return; }
+      pickerFiles = filterFiles(allFiles, buffer.slice(atPos + 1));
+      pickerIndex = 0;
+    };
+
+    const redraw = () => {
+      const inputLine = chalk.cyan(PREFIX) + (buffer || HINT);
+
+      // Build scrollable picker window of PICKER_MAX items.
+      const total = pickerFiles.length;
+      const scrollStart = total <= PICKER_MAX ? 0
+        : Math.min(Math.max(0, pickerIndex - Math.floor(PICKER_MAX / 2)), total - PICKER_MAX);
+      const windowFiles = pickerFiles.slice(scrollStart, scrollStart + PICKER_MAX);
+      const pickerRows = windowFiles.map((f, i) => {
+        const absIndex = scrollStart + i;
+        return absIndex === pickerIndex
+          ? '  ' + chalk.bgCyan.black(' ' + f + ' ')
+          : '  ' + chalk.dim(f);
+      });
+      if (scrollStart > 0) pickerRows.unshift(chalk.dim(`  ↑ ${scrollStart} more`));
+      const below = total - scrollStart - PICKER_MAX;
+      if (below > 0) pickerRows.push(chalk.dim(`  ↓ ${below} more`));
+
+      const rows = [
+        border(),
+        inputLine,
+        border(),
+        ...pickerRows,
+        statusBar(),
+      ];
+
+      // Move cursor back to the top of the drawn block, then clear down.
+      if (cursorLineOffset > 0) stdout.write(`\x1b[${cursorLineOffset}A`);
+      stdout.write('\r\x1b[0J');
+
+      stdout.write(rows.join('\n'));
+
+      // rows = [border, inputLine, border, ...pickerRows(N), statusBar]
+      // inputLine is always at index 1. After writing all rows cursor is on
+      // statusBar. Move up (pickerRows.length + 2) to land back on inputLine.
+      const upAmount = pickerRows.length + 2;
+      stdout.write(`\x1b[${upAmount}A\r`);
+      cursorLineOffset = 1; // inputLine is always 1 line from the top
+
+      const col = visibleLen(chalk.cyan(PREFIX)) + visibleLen(buffer) + 1;
+      stdout.write(`\x1b[${col}G`);
+    };
+
+    // Clear the panel (called before resolving so output flows cleanly below).
+    const clearPanel = () => {
+      if (cursorLineOffset > 0) stdout.write(`\x1b[${cursorLineOffset}A`);
+      stdout.write('\r\x1b[0J');
+      cursorLineOffset = 0;
+    };
+
+    const onSigint = () => {
+      clearPanel();
+      cleanup();
+      stdout.write('\n');
+      process.exit(0);
+    };
+
+    const cleanup = () => {
+      stdin.removeListener('data', onData);
+      process.removeListener('SIGINT', onSigint);
+      stdin.setRawMode(false);
+      stdin.pause();
+    };
+
+    const onData = (data) => {
+      const key = data.toString();
+
+      // Ctrl+C → exit
+      if (key === '\x03') { onSigint(); return; }
+
+      // Ctrl+Q → cancel prompt
+      if (key === '\x11') {
+        clearPanel();
+        cleanup();
+        stdout.write(chalk.dim('(cancelled)\n'));
+        resolve(null);
+        return;
+      }
+
+      // Ctrl+D → exit
+      if (key === '\x04') { onSigint(); return; }
+
+      // Enter
+      if (key === '\r' || key === '\n') {
+        if (pickerFiles.length > 0) {
+          const atPos = getAtPos();
+          if (atPos !== -1) {
+            buffer = buffer.slice(0, atPos) + '@' + pickerFiles[pickerIndex] + ' ';
+          }
+          pickerFiles = [];
+          pickerIndex = 0;
+          redraw();
+          return;
+        }
+        clearPanel();
+        cleanup();
+        stdout.write('\n');
+        resolve(buffer);
+        return;
+      }
+
+      // Escape → dismiss picker
+      if (key === '\x1b' || (key.startsWith('\x1b') && key.length > 1 && !key.startsWith('\x1b['))) {
+        pickerFiles = [];
+        redraw();
+        return;
+      }
+
+      // Arrow keys
+      if (key === '\x1b[A') {
+        if (pickerFiles.length > 0) { pickerIndex = (pickerIndex - 1 + pickerFiles.length) % pickerFiles.length; redraw(); }
+        return;
+      }
+      if (key === '\x1b[B') {
+        if (pickerFiles.length > 0) { pickerIndex = (pickerIndex + 1) % pickerFiles.length; redraw(); }
+        return;
+      }
+      if (key === '\x1b[C' || key === '\x1b[D') return; // left/right — ignore
+
+      // Backspace
+      if (key === '\x7f' || key === '\b') {
+        if (buffer.length > 0) { buffer = buffer.slice(0, -1); updatePicker(); redraw(); }
+        return;
+      }
+
+      // Ignore other control chars
+      if (key < ' ') return;
+
+      // Printable
+      buffer += key;
+      updatePicker();
+      redraw();
+    };
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    stdin.on('data', onData);
+    process.on('SIGINT', onSigint);
+    redraw();
+  });
+}

package/src/interactive.js

@@ -0,0 +1,278 @@
+import chalk from 'chalk';
+import { homedir } from 'os';
+import { resolve } from 'path';
+import { printLogo } from './ui/logo.js';
+import { streamChat, MODEL, MODELS, setModel } from './ollama.js';
+import { resolveFileRefs } from './files.js';
+import { parseEdits, applyEdit, renderDiff } from './editor.js';
+import { chatPrompt } from './input.js';
+import { getFiles } from './ui/picker.js';
+import { getToken, login } from './auth.js';
+
+/** Arrow-key selector. Returns the chosen string or null if cancelled. */
+function selectFrom(options, label) {
+  return new Promise((resolve) => {
+    let idx = 0;
+
+    const draw = () => {
+      process.stdout.write('\r\x1b[0J');
+      process.stdout.write(chalk.dim(label) + '\n');
+      options.forEach((o, i) => {
+        process.stdout.write(
+          i === idx
+            ? '  ' + chalk.bgCyan.black(` ${o} `) + '\n'
+            : '  ' + chalk.dim(o) + '\n'
+        );
+      });
+      // Move cursor back up to keep it stable
+      process.stdout.write(`\x1b[${options.length + 1}A`);
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      // Clear the drawn lines
+      process.stdout.write('\r\x1b[0J');
+    };
+
+    const onKey = (data) => {
+      const key = data.toString();
+      if (key === '\x1b[A') { idx = (idx - 1 + options.length) % options.length; draw(); return; }
+      if (key === '\x1b[B') { idx = (idx + 1) % options.length; draw(); return; }
+      if (key === '\r' || key === '\n') { cleanup(); resolve(options[idx]); return; }
+      if (key === '\x03' || key === '\x11') { cleanup(); resolve(null); return; }
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onKey);
+    draw();
+  });
+}
+
+/** Prompt y/n in raw mode, returns true for y/Y. */
+function confirm(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    const onKey = (key) => {
+      process.stdin.removeListener('data', onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      const answer = key.toLowerCase() === 'y';
+      process.stdout.write(answer ? chalk.green('y\n') : chalk.dim('n\n'));
+      resolve(answer);
+    };
+    process.stdin.on('data', onKey);
+  });
+}
+
+/** Read a visible line of input. */
+function promptLine(label) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    let buf = '';
+    const onData = (data) => {
+      const key = data.toString();
+      if (key === '\r' || key === '\n') {
+        process.stdin.removeListener('data', onData);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write('\n');
+        resolve(buf);
+      } else if (key === '\x7f' || key === '\b') {
+        if (buf.length > 0) { buf = buf.slice(0, -1); process.stdout.write('\b \b'); }
+      } else if (key >= ' ') {
+        buf += key;
+        process.stdout.write(key);
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onData);
+  });
+}
+
+/** Read a line of input without echo (for passwords). */
+function promptSecret(label) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    let buf = '';
+    const onData = (data) => {
+      const key = data.toString();
+      if (key === '\r' || key === '\n') {
+        process.stdin.removeListener('data', onData);
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write('\n');
+        resolve(buf);
+      } else if (key === '\x7f' || key === '\b') {
+        if (buf.length > 0) buf = buf.slice(0, -1);
+      } else if (key >= ' ') {
+        buf += key;
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onData);
+  });
+}
+
+export async function startInteractive() {
+  printLogo();
+
+  let allFiles = getFiles();
+  const chatMessages = [];
+
+  console.log(chalk.dim(`Chat with Markov (${MODEL}).\n`));
+
+  if (!getToken()) {
+    console.log(chalk.yellow('⚠  Not logged in. Use /login to authenticate.\n'));
+  }
+
+  while (true) {
+    const raw = await chatPrompt(chalk.magenta('you> '), allFiles);
+    if (raw === null) continue;
+    const trimmed = raw.trim();
+
+    if (!trimmed) continue;
+
+    // /login — authenticate and save token
+    if (trimmed === '/login') {
+      const email    = await promptLine('Email: ');
+      const password = await promptSecret('Password: ');
+      try {
+        await login(email, password);
+        console.log(chalk.green('✓ logged in\n'));
+      } catch (err) {
+        console.log(chalk.red(`✗ ${err.message}\n`));
+      }
+      continue;
+    }
+
+    // /models — pick active model
+    if (trimmed === '/models') {
+      const chosen = await selectFrom(MODELS, 'Select model:');
+      if (chosen) {
+        setModel(chosen);
+        console.log(chalk.dim(`\n🤖 switched to ${chalk.cyan(chosen)}\n`));
+      }
+      continue;
+    }
+
+    // /cd [path] — change working directory within this session
+    if (trimmed.startsWith('/cd')) {
+      const arg = trimmed.slice(3).trim();
+      const target = arg
+        ? resolve(process.cwd(), arg.replace(/^~/, homedir()))
+        : homedir();
+      try {
+        process.chdir(target);
+        allFiles = getFiles();
+        console.log(chalk.dim(`\n📁 ${process.cwd()}\n`));
+      } catch {
+        console.log(chalk.red(`\nno such directory: ${target}\n`));
+      }
+      continue;
+    }
+
+    const isEditMode = trimmed.startsWith('/edit ');
+    const message = isEditMode ? trimmed.slice(6).trim() : trimmed;
+
+    const { content, loaded, failed } = resolveFileRefs(message);
+
+    if (loaded.length > 0) {
+      console.log(chalk.dim(`\n📎 attached: ${loaded.map(f => chalk.cyan(`@${f}`)).join(', ')}`));
+    }
+    if (failed.length > 0) {
+      console.log(chalk.yellow(`\n⚠  not found: ${failed.map(f => `@${f}`).join(', ')}`));
+    }
+
+    chatMessages.push({ role: 'user', content });
+
+    // Animated waiting dots — cleared on first token
+    const DOTS = ['.', '..', '...'];
+    let dotIdx = 0;
+    let firstToken = true;
+    process.stdout.write(chalk.dim('\nMarkov › '));
+    const spinner = setInterval(() => {
+      process.stdout.write('\r' + chalk.dim('Markov › ' + DOTS[dotIdx % DOTS.length] + '   '));
+      dotIdx++;
+    }, 400);
+
+    const abortController = new AbortController();
+    try {
+
+      // Listen for Ctrl+Q on raw stdin to cancel the stream
+      const onCancel = (data) => {
+        if (data.toString() === '\x11') abortController.abort();
+      };
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', onCancel);
+
+      const reply = await streamChat(chatMessages, (token) => {
+        if (firstToken) {
+          clearInterval(spinner);
+          firstToken = false;
+          process.stdout.write('\r\x1b[0J' + chalk.dim('Markov ›\n\n'));
+        }
+        process.stdout.write(token);
+      }, undefined, abortController.signal);
+
+      process.stdin.removeListener('data', onCancel);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      clearInterval(spinner);
+
+      if (abortController.signal.aborted) {
+        console.log(chalk.dim('\n(cancelled)\n'));
+      } else {
+        console.log('\n');
+        chatMessages.push({ role: 'assistant', content: reply });
+
+        // Detect file edits in the response (only in /edit mode)
+        const edits = isEditMode ? parseEdits(reply, loaded) : [];
+        const appliedEdits = [];
+        for (const { filepath, content } of edits) {
+          renderDiff(filepath, content);
+          const confirmed = await confirm(chalk.bold(`Apply changes to ${chalk.cyan(filepath)}? [y/N] `));
+          if (confirmed) {
+            try {
+              applyEdit(filepath, content);
+              console.log(chalk.green(`✓ saved ${filepath}\n`));
+              appliedEdits.push({ filepath, content });
+            } catch (err) {
+              console.log(chalk.red(`✗ could not write ${filepath}: ${err.message}\n`));
+            }
+          } else {
+            console.log(chalk.dim('skipped\n'));
+          }
+        }
+
+        // Refresh chat context with updated file contents so the model
+        // doesn't reference stale content from earlier in the conversation.
+        if (appliedEdits.length > 0) {
+          const blocks = appliedEdits.map(({ filepath, content }) => `--- @${filepath} ---\n${content}\n---`);
+          chatMessages.push({
+            role: 'user',
+            content: `The following file(s) were just saved with the applied changes:\n\n${blocks.join('\n\n')}`,
+          });
+          chatMessages.push({ role: 'assistant', content: 'Got it, I have the updated file contents.' });
+        }
+      }
+    } catch (err) {
+      clearInterval(spinner);
+      if (!abortController.signal.aborted) {
+        console.log(chalk.red(`\n${err.message}\n`));
+      }
+    }
+  }
+}

package/src/ollama.js

@@ -0,0 +1,71 @@
+import { API_URL, getToken } from './auth.js';
+
+const getHeaders = () => {
+  const token = getToken();
+  return { 'Content-Type': 'application/json', ...(token && { Authorization: `Bearer ${token}` }) };
+};
+export const MODELS = ['gemma3:4b', 'qwen2.5-coder:0.5b', 'qwen2.5-coder:7b', 'qwen3:14b'];
+export let MODEL    = 'qwen3:14b';
+export function setModel(m) { MODEL = m; }
+
+/**
+ * Stream a chat response from Ollama.
+ * Calls onToken(string) for each token, returns the full response string.
+ * Pass an AbortSignal to allow cancellation mid-stream.
+ */
+export async function streamChat(messages, onToken, _model = MODEL, signal = null) {
+  let response;
+  try {
+    response = await fetch(`${API_URL}/ai/chat/stream`, {
+      method: 'POST',
+      headers: getHeaders(),
+      body: JSON.stringify({ messages, temperature: 0.2 }),
+      signal,
+    });
+  } catch (err) {
+    if (signal?.aborted) return '';
+    throw new Error(`Could not connect to ${API_URL}/ai/chat/stream — ${err.message}`);
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    throw new Error(`API error ${response.status} ${response.statusText}${body ? ': ' + body : ''}`);
+  }
+
+  const reader  = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullText  = '';
+  let buffer    = '';
+
+  try {
+    while (true) {
+      if (signal?.aborted) { reader.cancel(); break; }
+
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6);
+        if (data === '[DONE]') return fullText;
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.content) {
+            onToken(parsed.content);
+            fullText += parsed.content;
+          }
+        } catch { /* skip malformed */ }
+      }
+    }
+  } catch (err) {
+    if (!signal?.aborted) throw err;
+  } finally {
+    reader.releaseLock();
+  }
+
+  return fullText;
+}

package/src/ui/logo.js

@@ -0,0 +1,27 @@
+import gradient from 'gradient-string';
+
+const ASCII_ART = `                                    
+  ███╗   ███╗ █████╗ ██████╗ ██╗  ██╗ ██████╗ ██╗   ██╗  
+  ████╗ ████║██╔══██╗██╔══██╗██║ ██╔╝██╔═══██╗██║   ██║  
+  ██╔████╔██║███████║██████╔╝█████╔╝ ██    ██║██║   ██║ 
+  ██║╚██╔╝██║██╔══██║██╔══██╗██╔═██╗ ██║   ██║╚██╗ ██╔╝  
+  ██║ ╚═╝ ██║██║  ██║██║  ██║██║  ██╗╚██████╔╝ ╚████╔╝   
+  ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝   ╚═══╝        
+`;
+
+const SMALL_MARKOV = `
+  █   █  ██  █ ██ █  █  ██  █   █
+  ██ ██ █ ██ ██   ███  █  █  ███
+  █ █ █ █  █ █    █ ██  ██    █  █   
+`;
+
+const markovGradient = gradient(['#6366f1', '#a855f7', '#ec4899']);
+
+export function printLogo() {
+  console.log(markovGradient.multiline(ASCII_ART));
+  console.log('  A friendly CLI tool\n');
+}
+
+export function printSmallMarkov() {
+  console.log(markovGradient.multiline(SMALL_MARKOV));
+}

package/src/ui/picker.js

@@ -0,0 +1,31 @@
+import { readdirSync } from 'fs';
+import { join, relative } from 'path';
+
+const IGNORE = new Set([
+  '.git', 'node_modules', '.next', 'dist', 'build', '.cache',
+  'coverage', '__pycache__', '.venv', 'venv', '.DS_Store',
+]);
+const MAX_FILES = 300;
+
+export function getFiles(dir = process.cwd(), base = dir, depth = 0, acc = []) {
+  if (depth > 5 || acc.length >= MAX_FILES) return acc;
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return acc; }
+  for (const entry of entries) {
+    if (IGNORE.has(entry.name) || entry.name.startsWith('.')) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      getFiles(full, base, depth + 1, acc);
+    } else {
+      acc.push(relative(base, full));
+    }
+    if (acc.length >= MAX_FILES) break;
+  }
+  return acc;
+}
+
+export function filterFiles(files, query) {
+  if (!query) return files;
+  const q = query.toLowerCase();
+  return files.filter(f => f.toLowerCase().includes(q));
+}