codeply-cli 0.1.0

package/lib/textarea.mjs

@@ -0,0 +1,258 @@
+/**
+ * Multiline composer input.
+ *
+ * ink-text-input is single-line and submits on any \r, which also means pasting
+ * a code snippet fires a submit at the first newline. This replaces it.
+ *
+ * Getting a real shift+enter out of a terminal is the awkward part: by default
+ * both enter and shift+enter send the same byte (\r), so they are physically
+ * indistinguishable. We enable the kitty keyboard protocol's disambiguation
+ * flag on mount (\x1b[>1u), which makes modified enter arrive as CSI 13;<mod>u
+ * while leaving ordinary typing alone. Terminals that don't speak it ignore the
+ * sequence, so the fallbacks below carry them:
+ *
+ *   shift+enter   real, when the terminal supports CSI-u    → newline
+ *   alt+enter     arrives as ESC \r                          → newline
+ *   ctrl+j        arrives as \n, always distinct from \r     → newline
+ *   trailing \    backslash at end of line, then enter       → newline
+ *   enter                                                    → submit
+ *
+ * Ink reports \r as key.return with input '\r'. \n parses as name 'enter', so
+ * key.return is false — that difference is what makes ctrl+j detectable.
+ */
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+
+const KITTY_ON = '\x1b[>1u';
+const KITTY_OFF = '\x1b[<u';
+const KITTY_QUERY = '\x1b[?u';
+
+// Replies the terminal sends back to our own queries. They arrive on stdin
+// exactly like typed text, so without this they get inserted into the draft.
+const TERMINAL_REPORT = /^\[[?0-9;]*[uRc]$/;
+
+const INVERSE = '\x1b[7m';      // the cursor block
+const INVERSE_OFF = '\x1b[27m';
+const GREY = '\x1b[90m';        // placeholder
+const GREY_OFF = '\x1b[39m';
+
+// CSI 13;<modifier>u — enter with any modifier held.
+const CSI_MODIFIED_ENTER = /^\[13;\d+u$/;
+
+/**
+ * Ask the terminal for kitty key disambiguation, then ask whether it took.
+ *
+ * Windows Terminal does not implement this protocol (it has its own
+ * win32-input-mode instead), so on Windows the query simply goes unanswered and
+ * shift+enter stays physically identical to enter. That is why the UI reports
+ * whichever newline key actually works rather than promising shift+enter
+ * everywhere — see `modifiedEnterWorks` in tui.mjs.
+ */
+export function enableModifiedEnter(stdout) {
+  if (!stdout || !stdout.isTTY) return () => {};
+  let restored = false;
+  const restore = () => {
+    if (restored) return;
+    restored = true;
+    try { stdout.write(KITTY_OFF); } catch {}
+  };
+  try {
+    stdout.write(KITTY_ON);
+    stdout.write(KITTY_QUERY); // a reply means the protocol is really supported
+  } catch {}
+  process.once('exit', restore);
+  return restore;
+}
+
+/** True for a terminal's answer to one of our capability queries. */
+export function isTerminalReport(input) {
+  return TERMINAL_REPORT.test(input);
+}
+
+/** Split a string into rendered rows, wrapping each logical line at `width`. */
+function layout(value, width) {
+  const rows = [];
+  const logical = value.split('\n');
+  for (let li = 0; li < logical.length; li++) {
+    const line = logical[li];
+    let start = 0;
+    do {
+      const chunk = line.slice(start, start + width);
+      rows.push({ line: li, start, text: chunk });
+      start += width;
+    } while (start < line.length);
+  }
+  return rows;
+}
+
+/** Absolute offset of the start of logical line `n`. */
+function lineOffset(value, n) {
+  let offset = 0;
+  const lines = value.split('\n');
+  for (let i = 0; i < n; i++) offset += lines[i].length + 1;
+  return offset;
+}
+
+export default function TextArea({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = '',
+  width = 60,
+  focus = true,
+  showCursor = true,
+  // When the command palette is open it owns up/down for selection, so the
+  // composer must not also move its cursor on those keys.
+  allowVertical = true,
+}) {
+  const [cursor, setCursor] = React.useState(value.length);
+
+  // Keep the cursor inside the value when it changes from outside (e.g. a
+  // command completion replacing the draft).
+  React.useEffect(() => {
+    setCursor((c) => Math.min(c, value.length));
+  }, [value]);
+
+  const apply = React.useCallback((next, nextCursor) => {
+    onChange(next);
+    setCursor(Math.max(0, Math.min(nextCursor, next.length)));
+  }, [onChange]);
+
+  const insert = React.useCallback((text) => {
+    const next = value.slice(0, cursor) + text + value.slice(cursor);
+    apply(next, cursor + text.length);
+  }, [value, cursor, apply]);
+
+  const newline = React.useCallback(() => insert('\n'), [insert]);
+
+  useInput((input, key) => {
+    if (!focus) return;
+
+    // ── newline vs submit ──
+    if (CSI_MODIFIED_ENTER.test(input)) { newline(); return; }
+    // Capability replies must never land in the draft as literal text.
+    if (TERMINAL_REPORT.test(input)) return;
+    if (key.return && key.shift) { newline(); return; }
+    if (!key.return && (input === '\r' || input === '\n')) { newline(); return; } // alt+enter, ctrl+j
+
+    if (key.return) {
+      // Trailing backslash is the universal fallback for terminals that send
+      // the same byte for enter and shift+enter.
+      if (value.slice(0, cursor).endsWith('\\')) {
+        apply(value.slice(0, cursor - 1) + '\n' + value.slice(cursor), cursor);
+        return;
+      }
+      onSubmit(value);
+      return;
+    }
+
+    // ── multi-character input is a paste ──
+    if (input.length > 1 && !key.ctrl && !key.meta) {
+      insert(input.replace(/\r\n?/g, '\n'));
+      return;
+    }
+
+    // ── editing ──
+    if (key.backspace || (key.delete && !key.meta)) {
+      // Ink reports the DEL byte (0x7f) as `delete`, which is what most
+      // terminals actually send for the backspace key.
+      if (cursor > 0) apply(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+      return;
+    }
+
+    if (key.ctrl) {
+      switch (input) {
+        case 'a': setCursor(lineOffset(value, value.slice(0, cursor).split('\n').length - 1)); return;
+        case 'e': {
+          const lines = value.split('\n');
+          const li = value.slice(0, cursor).split('\n').length - 1;
+          setCursor(lineOffset(value, li) + lines[li].length);
+          return;
+        }
+        case 'k': {
+          const rest = value.slice(cursor);
+          const nl = rest.indexOf('\n');
+          apply(value.slice(0, cursor) + (nl === -1 ? '' : rest.slice(nl)), cursor);
+          return;
+        }
+        case 'u': {
+          const li = value.slice(0, cursor).split('\n').length - 1;
+          const start = lineOffset(value, li);
+          apply(value.slice(0, start) + value.slice(cursor), start);
+          return;
+        }
+        case 'w': {
+          const before = value.slice(0, cursor);
+          const trimmed = before.replace(/\s*\S+$/, '');
+          apply(trimmed + value.slice(cursor), trimmed.length);
+          return;
+        }
+        default: return;
+      }
+    }
+
+    // ── movement ──
+    if (key.leftArrow) { setCursor((c) => Math.max(0, c - 1)); return; }
+    if (key.rightArrow) { setCursor((c) => Math.min(value.length, c + 1)); return; }
+
+    if (key.upArrow || key.downArrow) {
+      if (!allowVertical) return;
+      const lines = value.split('\n');
+      const li = value.slice(0, cursor).split('\n').length - 1;
+      const col = cursor - lineOffset(value, li);
+      const target = key.upArrow ? li - 1 : li + 1;
+      if (target < 0 || target >= lines.length) return;
+      setCursor(lineOffset(value, target) + Math.min(col, lines[target].length));
+      return;
+    }
+
+    // ── plain character ──
+    if (input && !key.meta && !key.ctrl && !key.tab && !key.escape) {
+      insert(input);
+    }
+  }, { isActive: focus });
+
+  // ── render ──
+  const w = Math.max(8, width);
+
+  if (value.length === 0) {
+    return React.createElement(
+      Text,
+      null,
+      showCursor && focus
+        ? INVERSE + (placeholder[0] || ' ') + INVERSE_OFF +
+          GREY + placeholder.slice(1) + GREY_OFF
+        : GREY + placeholder + GREY_OFF
+    );
+  }
+
+  const rows = layout(value, w);
+  const lines = value.split('\n');
+  const curLine = value.slice(0, cursor).split('\n').length - 1;
+  const curCol = cursor - lineOffset(value, curLine);
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    ...rows.map((row, i) => {
+      const isCursorRow =
+        focus && showCursor &&
+        row.line === curLine &&
+        curCol >= row.start &&
+        (curCol < row.start + w || (row.start + w >= lines[row.line].length && curCol <= lines[row.line].length));
+
+      if (!isCursorRow) {
+        return React.createElement(Text, { key: i }, row.text || ' ');
+      }
+      const at = curCol - row.start;
+      const before = row.text.slice(0, at);
+      const under = row.text[at] ?? ' ';
+      const after = row.text.slice(at + 1);
+      return React.createElement(
+        Text,
+        { key: i },
+        before + INVERSE + under + INVERSE_OFF + after
+      );
+    })
+  );
+}

package/lib/tools.mjs

@@ -0,0 +1,376 @@
+/**
+ * Codeply agent tools.
+ *
+ * Each tool is a plain async function returning { ok, output, meta }. `output`
+ * is what gets fed back to the model, so it is always truncated to a sane size —
+ * an untruncated file read is the fastest way to blow the context budget and
+ * make the agent stupid halfway through a task.
+ *
+ * Anything that changes the user's machine (write_file, edit_file, run) goes
+ * through ctx.approve() first and never side-steps it.
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { exec } from 'child_process';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const editEngine = require('./edit-engine.js');
+const applyLimit = require('./apply-limit.js');
+const config = require('./config.js');
+
+// A write is a real "apply" against the shared 100/day cap only when it's
+// actually spending the shared codeply proxy — Ollama (local or the user's
+// own cloud key) never touches Codeply's account/infrastructure, so it isn't
+// gated by it.
+const CAPPED_TOOLS = new Set(['write_file', 'edit_file']);
+
+const MAX_TOOL_OUTPUT = 12000;   // chars fed back to the model per tool call
+const MAX_READ_LINES = 600;
+const MAX_SEARCH_HITS = 60;
+const RUN_TIMEOUT_MS = 120000;
+
+const IGNORED_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '.next', 'out', 'coverage',
+  '.cache', '.turbo', 'vendor', '__pycache__', '.venv', 'venv', 'target',
+]);
+
+const TEXT_EXT = new Set([
+  '.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.json', '.html', '.htm',
+  '.css', '.scss', '.sass', '.less', '.md', '.txt', '.py', '.rb', '.go',
+  '.rs', '.java', '.c', '.h', '.cpp', '.hpp', '.cs', '.php', '.sh', '.yml',
+  '.yaml', '.toml', '.xml', '.svg', '.vue', '.svelte', '.sql', '.env',
+]);
+
+function truncate(text, max = MAX_TOOL_OUTPUT) {
+  if (text.length <= max) return text;
+  const kept = text.slice(0, max);
+  return `${kept}\n\n[… truncated, ${text.length - max} more characters. Narrow the request if you need the rest.]`;
+}
+
+/** Resolve a model-supplied path against cwd and report whether it escapes it. */
+function resolvePath(p, cwd) {
+  const abs = path.isAbsolute(p) ? path.normalize(p) : path.resolve(cwd, p);
+  const rel = path.relative(cwd, abs);
+  const outside = rel.startsWith('..') || path.isAbsolute(rel);
+  return { abs, rel: outside ? abs : rel.replace(/\\/g, '/') || '.', outside };
+}
+
+/** Minimal glob -> RegExp. `**` crosses separators, `*` and `?` do not. */
+function globToRegex(glob) {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === '*') {
+      if (glob[i + 1] === '*') {
+        i++;
+        if (glob[i + 1] === '/') { i++; re += '(?:.*/)?'; }
+        else re += '.*';
+      } else {
+        re += '[^/]*';
+      }
+    } else if (c === '?') {
+      re += '[^/]';
+    } else if ('.+^${}()|[]'.includes(c) || c === '\\') {
+      re += '\\' + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp(`^${re}$`, 'i');
+}
+
+/** Depth-first file walk that skips build/vendor noise and bails out early. */
+function walkFiles(root, { maxFiles = 4000, maxDepth = 12 } = {}) {
+  const out = [];
+  const stack = [{ dir: root, depth: 0 }];
+  while (stack.length && out.length < maxFiles) {
+    const { dir, depth } = stack.pop();
+    if (depth > maxDepth) continue;
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') && entry.name !== '.env') {
+        if (entry.isDirectory()) continue;
+      }
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        stack.push({ dir: full, depth: depth + 1 });
+      } else if (entry.isFile()) {
+        out.push(full);
+        if (out.length >= maxFiles) break;
+      }
+    }
+  }
+  return out;
+}
+
+// ─── Tools ──────────────────────────────────────────────────────────────────
+
+async function list_dir(args, ctx) {
+  const target = args.path || '.';
+  const { abs, rel } = resolvePath(target, ctx.cwd);
+  if (!fs.existsSync(abs)) return { ok: false, output: `No such directory: ${rel}` };
+  if (!fs.statSync(abs).isDirectory()) return { ok: false, output: `Not a directory: ${rel}` };
+
+  let entries;
+  try { entries = fs.readdirSync(abs, { withFileTypes: true }); }
+  catch (e) { return { ok: false, output: `Cannot read ${rel}: ${e.message}` }; }
+
+  const dirs = [];
+  const files = [];
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      dirs.push(IGNORED_DIRS.has(e.name) ? `${e.name}/  (skipped)` : `${e.name}/`);
+    } else if (e.isFile()) {
+      let size = '';
+      try { size = `  ${fs.statSync(path.join(abs, e.name)).size}b`; } catch {}
+      files.push(`${e.name}${size}`);
+    }
+  }
+  dirs.sort(); files.sort();
+  const body = [...dirs, ...files].join('\n') || '(empty)';
+  return { ok: true, output: truncate(`${rel}/\n${body}`), meta: { label: rel, count: dirs.length + files.length } };
+}
+
+async function read_file(args, ctx) {
+  const target = args.path;
+  if (!target) return { ok: false, output: 'read_file needs a <path>.' };
+  const { abs, rel } = resolvePath(target, ctx.cwd);
+  if (!fs.existsSync(abs)) return { ok: false, output: `No such file: ${rel}` };
+  if (fs.statSync(abs).isDirectory()) return { ok: false, output: `${rel} is a directory — use list_dir.` };
+
+  let content;
+  try { content = fs.readFileSync(abs, 'utf8'); }
+  catch (e) { return { ok: false, output: `Cannot read ${rel}: ${e.message}` }; }
+
+  const allLines = content.split('\n');
+  const offset = Math.max(0, parseInt(args.offset, 10) || 0);
+  const limit = Math.min(parseInt(args.limit, 10) || MAX_READ_LINES, MAX_READ_LINES);
+  const slice = allLines.slice(offset, offset + limit);
+  const width = String(offset + slice.length).length;
+
+  const numbered = slice
+    .map((l, i) => `${String(offset + i + 1).padStart(width)}│${l}`)
+    .join('\n');
+  const more = allLines.length > offset + slice.length
+    ? `\n[… ${allLines.length - offset - slice.length} more lines. Re-read with offset=${offset + slice.length}.]`
+    : '';
+
+  return {
+    ok: true,
+    output: truncate(`${rel} (${allLines.length} lines)\n${numbered}${more}`),
+    meta: { label: rel, count: allLines.length },
+  };
+}
+
+async function write_file(args, ctx) {
+  const target = args.path;
+  if (!target) return { ok: false, output: 'write_file needs a <path>.' };
+  if (args.content == null) return { ok: false, output: 'write_file needs a <content> block.' };
+
+  const { abs, rel, outside } = resolvePath(target, ctx.cwd);
+  const existed = fs.existsSync(abs);
+  const before = existed ? fs.readFileSync(abs, 'utf8') : '';
+  const after = args.content;
+  if (existed && before === after) {
+    return { ok: true, output: `${rel} already has exactly this content — nothing written.`, meta: { label: rel, noop: true } };
+  }
+
+  const beforeLines = existed ? before.split('\n').length : 0;
+  const afterLines = after.split('\n').length;
+
+  const verdict = await ctx.approve({
+    tool: 'write_file',
+    title: existed ? `Overwrite ${rel}` : `Create ${rel}`,
+    detail: existed
+      ? `${beforeLines} lines → ${afterLines} lines`
+      : `${afterLines} lines`,
+    danger: outside,
+  });
+  if (verdict === 'reject') return { ok: false, output: `User declined the write to ${rel}.`, meta: { rejected: true } };
+
+  try {
+    const dir = path.dirname(abs);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(abs, after, 'utf8');
+  } catch (e) {
+    return { ok: false, output: `Cannot write ${rel}: ${e.message}` };
+  }
+
+  return {
+    ok: true,
+    output: `Wrote ${rel} (${afterLines} lines). The write succeeded exactly as you sent it — ` +
+      `do NOT read the file back to confirm it.`,
+    meta: { label: rel, added: afterLines, removed: beforeLines, wrote: true },
+  };
+}
+
+async function edit_file(args, ctx) {
+  const target = args.path;
+  if (!target) return { ok: false, output: 'edit_file needs a <path>.' };
+  if (!args.search) return { ok: false, output: 'edit_file needs a <search> block.' };
+  if (args.replace == null) return { ok: false, output: 'edit_file needs a <replace> block.' };
+
+  const { abs, rel, outside } = resolvePath(target, ctx.cwd);
+  if (!fs.existsSync(abs)) return { ok: false, output: `No such file: ${rel}. Use write_file to create it.` };
+
+  const before = fs.readFileSync(abs, 'utf8');
+  // Dry-run through the same matcher that will do the real edit, so the user
+  // is never asked to approve something that turns out not to apply.
+  const attempt = editEngine.applySearchReplace(before, args.search, args.replace);
+  if (!attempt.ok) {
+    const why = attempt.error === 'notfound'
+      ? 'that exact text is not in the file — re-read it and copy the block verbatim'
+      : attempt.error === 'multiple'
+        ? 'that text appears more than once — include more surrounding lines to make it unique'
+        : 'the search block was empty';
+    return { ok: false, output: `Edit to ${rel} did not apply: ${why}.` };
+  }
+
+  const removed = args.search.split('\n').length;
+  const added = args.replace.split('\n').length;
+
+  const verdict = await ctx.approve({
+    tool: 'edit_file',
+    title: `Edit ${rel}`,
+    detail: `-${removed} +${added} lines`,
+    diff: { search: args.search, replace: args.replace },
+    danger: outside,
+  });
+  if (verdict === 'reject') return { ok: false, output: `User declined the edit to ${rel}.`, meta: { rejected: true } };
+
+  try { fs.writeFileSync(abs, attempt.content, 'utf8'); }
+  catch (e) { return { ok: false, output: `Cannot write ${rel}: ${e.message}` }; }
+
+  const nowLines = attempt.content.split('\n').length;
+  return {
+    ok: true,
+    // The "do not re-read" line is load-bearing: without it the model burns a
+    // whole extra round-trip reading the file back, and stuffs the entire file
+    // into context again, which slows down every following step.
+    output: `Edited ${rel} (-${removed} +${added} lines). The file is now ${nowLines} lines. ` +
+      `The change was matched and applied successfully — do NOT read the file back to confirm it.`,
+    meta: { label: rel, added, removed, wrote: true },
+  };
+}
+
+async function search(args, ctx) {
+  const pattern = args.pattern;
+  if (!pattern) return { ok: false, output: 'search needs a <pattern>.' };
+
+  let re;
+  try { re = new RegExp(pattern, 'i'); }
+  catch (e) { return { ok: false, output: `Invalid regex: ${e.message}` }; }
+
+  const globRe = args.glob ? globToRegex(args.glob) : null;
+  const root = args.path ? resolvePath(args.path, ctx.cwd).abs : ctx.cwd;
+  const files = walkFiles(root);
+
+  const hits = [];
+  let scanned = 0;
+  for (const file of files) {
+    const rel = path.relative(ctx.cwd, file).replace(/\\/g, '/');
+    if (globRe && !globRe.test(rel)) continue;
+    const ext = path.extname(file).toLowerCase();
+    if (ext && !TEXT_EXT.has(ext)) continue;
+    let content;
+    try {
+      if (fs.statSync(file).size > 2_000_000) continue;
+      content = fs.readFileSync(file, 'utf8');
+    } catch { continue; }
+    scanned++;
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        hits.push(`${rel}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+        if (hits.length >= MAX_SEARCH_HITS) break;
+      }
+    }
+    if (hits.length >= MAX_SEARCH_HITS) break;
+  }
+
+  const header = hits.length
+    ? `${hits.length}${hits.length >= MAX_SEARCH_HITS ? '+' : ''} match(es) across ${scanned} file(s):`
+    : `No matches for /${pattern}/ across ${scanned} file(s).`;
+  return { ok: true, output: truncate(`${header}\n${hits.join('\n')}`), meta: { label: pattern, count: hits.length } };
+}
+
+async function run(args, ctx) {
+  const command = (args.command || '').trim();
+  if (!command) return { ok: false, output: 'run needs a <command>.' };
+
+  const verdict = await ctx.approve({
+    tool: 'run',
+    title: 'Run command',
+    detail: command,
+    danger: /\brm\s+-rf\b|\bdel\s+\/[sf]\b|format\s|mkfs|>\s*\/dev\/sd|shutdown|reboot|:\(\)\{|curl[^|]*\|\s*(ba)?sh/i.test(command),
+  });
+  if (verdict === 'reject') return { ok: false, output: `User declined to run: ${command}`, meta: { rejected: true } };
+
+  return new Promise((resolve) => {
+    exec(command, { cwd: ctx.cwd, timeout: RUN_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
+      (err, stdout, stderr) => {
+        const code = err ? (err.code == null ? 1 : err.code) : 0;
+        const parts = [];
+        if (stdout && stdout.trim()) parts.push(stdout.trimEnd());
+        if (stderr && stderr.trim()) parts.push(`[stderr]\n${stderr.trimEnd()}`);
+        if (err && err.killed) parts.push(`[timed out after ${RUN_TIMEOUT_MS / 1000}s]`);
+        const body = parts.join('\n') || '(no output)';
+        resolve({
+          ok: true, // a non-zero exit is a real result the model must see, not a tool failure
+          output: truncate(`$ ${command}\n[exit ${code}]\n${body}`),
+          meta: { label: command, exitCode: code },
+        });
+      });
+  });
+}
+
+export const TOOLS = { list_dir, read_file, write_file, edit_file, search, run };
+
+export const TOOL_NEEDS_APPROVAL = new Set(['write_file', 'edit_file', 'run']);
+
+/** Human-facing verb + colour hint for the transcript. */
+export const TOOL_DISPLAY = {
+  list_dir:   { verb: 'list',   icon: '▸' },
+  read_file:  { verb: 'read',   icon: '▸' },
+  write_file: { verb: 'write',  icon: '✎' },
+  edit_file:  { verb: 'edit',   icon: '✎' },
+  search:     { verb: 'search', icon: '▸' },
+  run:        { verb: 'run',    icon: '$' },
+};
+
+export async function executeTool(name, args, ctx) {
+  const fn = TOOLS[name];
+  if (!fn) {
+    return { ok: false, output: `Unknown tool "${name}". Available: ${Object.keys(TOOLS).join(', ')}.` };
+  }
+
+  // Same cap the desktop app enforces, same account — checked BEFORE the
+  // approval prompt so the user is never asked to confirm a write that's
+  // about to be blocked anyway.
+  const capped = CAPPED_TOOLS.has(name) && config.getConfig().provider === 'codeply';
+  if (capped) {
+    const limit = await applyLimit.checkApplyLimit();
+    if (!limit.allowed) {
+      return {
+        ok: false,
+        output: limit.error || `Daily apply limit reached (${limit.count}/${limit.limit}). This is shared with the Codeply desktop app and resets at midnight UTC.`,
+      };
+    }
+  }
+
+  try {
+    const result = await fn(args, ctx);
+    if (capped && result.ok && result.meta?.wrote) {
+      await applyLimit.recordApplyEvent(args.path);
+    }
+    return result;
+  } catch (e) {
+    return { ok: false, output: `${name} failed: ${e.message}` };
+  }
+}
+
+export { resolvePath, walkFiles, truncate };

package/lib/tui.js

@@ -0,0 +1,7 @@
+/**
+ * Legacy CJS stub — the interactive TUI lives in tui.mjs (ESM + Ink).
+ * Entry point: bin/codeply.js → dynamic import('./lib/tui.mjs')
+ */
+module.exports = function deprecatedTui() {
+  throw new Error('Use lib/tui.mjs via the codeply entrypoint (node bin/codeply.js).');
+};