prior-cli 1.7.10 → 1.7.12

package/bin/prior.js

@@ -169,6 +169,16 @@ const TOOL_HINTS = [
     ],
     hint: '[TOOL DIRECTIVE: You MUST call ip_lookup]',
   },
+  {
+    tool: 'file_edit',
+    patterns: [
+      /\bedit\b/i, /\bmodify\b/i, /\bchange\b.*\b(file|function|line|code|return|value|variable)\b/i,
+      /\brefactor\b/i, /\brename\b.*\b(function|variable|method)\b/i,
+      /\bfix\b.*\b(bug|file|code|function|typo)\b/i, /\breplace\b.*\b(in|line|text|code)\b/i,
+      /\bupdate\b.*\b(file|function|code|line)\b/i,
+    ],
+    hint: '[TOOL DIRECTIVE: To change part of an existing file, you MUST use the <edit path="..."> tag with SEARCH/REPLACE markers — do NOT rewrite the whole file with <write>, and never say you cannot edit files]',
+  },
   {
     tool: 'generate_image',
     patterns: [
@@ -191,6 +201,59 @@ function injectToolHint(text) {
   return text;
 }
 
+// ── @file context attachment ───────────────────────────────────
+// Expands  @path/to/file  references in a prompt into inline file context,
+// so the model sees the contents without a separate file_read round-trip.
+const MAX_ATTACH_BYTES = 256 * 1024;
+function expandFileRefs(input, cwd) {
+  const refRe = /(?:^|\s)@([^\s]+)/g;
+  const attached = [];
+  const seen = new Set();
+  let m;
+  while ((m = refRe.exec(input)) !== null) {
+    let ref = m[1].replace(/[.,;:)\]]+$/, ''); // trim trailing punctuation
+    if (!ref || seen.has(ref)) continue;
+    const resolved = (/^[a-zA-Z]:[/\\]/.test(ref) || path.isAbsolute(ref)) ? ref : path.resolve(cwd, ref);
+    try {
+      const stat = fs.statSync(resolved);
+      if (!stat.isFile() || stat.size > MAX_ATTACH_BYTES) continue;
+      const content = fs.readFileSync(resolved, 'utf8');
+      if (content.indexOf('\x00') !== -1) continue; // binary
+      attached.push({ ref, content, lines: content.split('\n').length });
+      seen.add(ref);
+    } catch { /* not a readable file — leave the @token as literal text */ }
+  }
+  if (!attached.length) return { message: input, attached };
+  const ctx = attached
+    .map(a => `--- Contents of ${a.ref} ---\n${a.content}`)
+    .join('\n\n');
+  return { message: `${input}\n\n[Attached file context]\n${ctx}`, attached };
+}
+
+// Live completions for an @file token being typed. `partial` is the text
+// after @ (e.g. "lib/to").  Returns up to `limit` matches, dirs first.
+const REF_SKIP_DIRS = new Set(['node_modules', '.git', '.next', 'dist', 'build', '.cache', 'coverage', 'vendor']);
+function fileRefSuggestions(partial, cwd, limit = 6) {
+  const slash   = Math.max(partial.lastIndexOf('/'), partial.lastIndexOf('\\'));
+  const dirPart = slash >= 0 ? partial.slice(0, slash) : '';
+  const prefix  = (slash >= 0 ? partial.slice(slash + 1) : partial).toLowerCase();
+  const baseDir = dirPart
+    ? (path.isAbsolute(dirPart) ? dirPart : path.resolve(cwd, dirPart))
+    : cwd;
+  let entries;
+  try { entries = fs.readdirSync(baseDir, { withFileTypes: true }); } catch { return []; }
+  const out = [];
+  for (const e of entries) {
+    if (e.name.startsWith('.') && !prefix.startsWith('.')) continue;   // hide dotfiles unless asked
+    if (e.isDirectory() && REF_SKIP_DIRS.has(e.name)) continue;
+    if (!e.name.toLowerCase().startsWith(prefix)) continue;
+    const ref = (dirPart ? dirPart.replace(/\\/g, '/') + '/' : '') + e.name;
+    out.push({ ref, isDir: e.isDirectory() });
+  }
+  out.sort((a, b) => (a.isDir === b.isDir ? a.ref.localeCompare(b.ref) : a.isDir ? -1 : 1));
+  return out.slice(0, limit);
+}
+
 function fmtElapsed(ms) {
   const s = Math.floor(ms / 1000);
   if (s < 60) return `${s}s`;
@@ -824,6 +887,13 @@ async function startChat(opts = {}) {
     terminal: true,
     historySize: 100,
     completer: line => {
+      // @file completion — complete the @token at the end of the line
+      const at = line.match(/(?:^|\s)@([^\s]*)$/);
+      if (at) {
+        const matches = fileRefSuggestions(at[1], process.cwd(), 20)
+          .map(s => '@' + (s.isDir ? s.ref + '/' : s.ref));
+        return [matches, '@' + at[1]];
+      }
       const cmds = ['/help', '/clear', '/censored', '/uncensored', '/login', '/logout', '/exit'];
       if (!line.startsWith('/')) return [[], line];
       const hits = cmds.filter(cmd => cmd.startsWith(line));
@@ -852,7 +922,7 @@ async function startChat(opts = {}) {
   );
   console.log(accountBadge);
   console.log(c.muted(`  ${cwdShort}`));
-  console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· file  web  shell  image  prior-network'));
+  console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· read  edit  search  web  shell  image  ·  @file to attach'));
 
   console.log(DIVIDER);
   console.log(c.muted('  /help  /clear  /update  /compact  /timer  /save  /load  /saves  /delete  /exit'));
@@ -933,6 +1003,22 @@ async function startChat(opts = {}) {
         }
       }
 
+      // @file completions — when the token at the end of the line starts with @
+      const atMatch = (line || '').match(/(?:^|\s)@([^\s]*)$/);
+      if (atMatch) {
+        const sugg = fileRefSuggestions(atMatch[1], process.cwd());
+        for (const s of sugg) {
+          const label = s.isDir ? s.ref + '/' : s.ref;
+          const icon  = s.isDir ? '📁' : '📄';
+          process.stdout.write(`\x1b[B\r\x1b[2K  ${c.brand('@')}${c.white(label.padEnd(30))}${c.dim(icon)}`);
+          rows++;
+        }
+        if (sugg.length) {
+          process.stdout.write(`\x1b[B\r\x1b[2K  ${c.dim('tab to complete  ·  attaches file contents as context')}`);
+          rows++;
+        }
+      }
+
       process.stdout.write('\x1b[u');
       _subRowCount = rows;
     }
@@ -1250,7 +1336,7 @@ async function startChat(opts = {}) {
             banner();
             console.log(DIVIDER);
             console.log(c.brand('  Prior AI') + c.muted('  ·  ') + c.muted(`@${user}`));
-            console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· file  web  shell  image  prior-network'));
+            console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· read  edit  search  web  shell  image  ·  @file to attach'));
             console.log(DIVIDER);
             console.log('');
             return loop();
@@ -1640,6 +1726,13 @@ Be concise but thorough — this summary replaces the full history to save conte
           console.log(c.brand('  ◈') + c.dim(`  ${label} attached`));
         }
 
+        // Expand any @file references into inline context
+        const { message: expandedInput, attached } = expandFileRefs(input, process.cwd());
+        if (attached.length) {
+          console.log(c.brand('  ◈') + c.muted('  attached: ' +
+            attached.map(a => `${a.ref} (${a.lines} line${a.lines !== 1 ? 's' : ''})`).join(', ')));
+        }
+
         let responseText     = '';
         let _progressStarted = false;
         const _thinkStart    = Date.now();
@@ -1661,7 +1754,7 @@ Be concise but thorough — this summary replaces the full history to save conte
 
           _currentAbortController = new AbortController();
           await runAgent({
-            messages:       [...chatHistory, { role: 'user', content: injectToolHint(input) }],
+            messages:       [...chatHistory, { role: 'user', content: injectToolHint(expandedInput) }],
             model:          currentModel,
             cwd:            process.cwd(),
             projectContext,
@@ -1761,7 +1854,7 @@ Be concise but thorough — this summary replaces the full history to save conte
           _currentAbortController = null;
         }
 
-        chatHistory.push({ role: 'user', content: input });
+        chatHistory.push({ role: 'user', content: expandedInput });
         if (responseText) chatHistory.push({ role: 'assistant', content: responseText });
 
         process.stdout.write('\n');
@@ -1828,6 +1921,78 @@ program
   .option('-m, --model <model>', 'Model to use')
   .action(opts => startChat(opts));
 
+// ── RUN (one-shot / non-interactive) ───────────────────────────
+program
+  .command('run [prompt...]')
+  .description('One-shot prompt — prints the answer and exits (scriptable, pipe-able)')
+  .option('-m, --model <model>', 'Model to use')
+  .option('-y, --yes',           'Auto-approve tool actions (run_command, file edits/writes)')
+  .option('-q, --quiet',         'Print only the final answer (suppress tool activity)')
+  .action(async (promptParts, opts) => {
+    requireAuth();
+
+    // Gather prompt from args + piped stdin
+    let prompt = (promptParts || []).join(' ').trim();
+    if (!process.stdin.isTTY) {
+      const piped = await new Promise(res => {
+        let buf = ''; process.stdin.setEncoding('utf8');
+        process.stdin.on('data', d => buf += d);
+        process.stdin.on('end', () => res(buf.trim()));
+        setTimeout(() => res(buf.trim()), 50); // no pipe → don't hang
+      });
+      if (piped) prompt = prompt ? `${prompt}\n\n${piped}` : piped;
+    }
+    if (!prompt) { console.error(c.err('  ✗ No prompt. Usage: prior run "your question"  (or pipe via stdin)')); process.exit(1); }
+
+    const cwd = process.cwd();
+    const { message, attached } = expandFileRefs(prompt, cwd);
+    if (attached.length && !opts.quiet) {
+      console.error(c.muted('  ◈ attached: ' + attached.map(a => a.ref).join(', ')));
+    }
+
+    // Load prior.md if present
+    let projectContext = null;
+    try { projectContext = fs.readFileSync(path.join(cwd, 'prior.md'), 'utf8'); } catch {}
+
+    let responseText = '';
+    let hadError     = false;
+    try {
+      await runAgent({
+        messages:       [{ role: 'user', content: injectToolHint(message) }],
+        model:          opts.model || null,
+        cwd,
+        projectContext,
+        confirm: async ({ name }) => {
+          if (opts.yes) return true;
+          console.error(c.warn(`  ⚠ Skipping ${name} — re-run with --yes to allow tool actions in one-shot mode.`));
+          return false;
+        },
+        send: ev => {
+          switch (ev.type) {
+            case 'tool_start':
+              if (!opts.quiet) console.error(c.dim(`  ◈ ${ev.name}`));
+              break;
+            case 'tool_error':
+              if (!opts.quiet) console.error(c.err(`  ✗ ${ev.name}: ${ev.error}`));
+              break;
+            case 'text':
+              if (ev.content) { process.stdout.write(ev.content); responseText += ev.content; }
+              break;
+            case 'error':
+              hadError = true;
+              console.error(c.err(`  ✗ ${ev.message}`));
+              break;
+          }
+        },
+      });
+    } catch (err) {
+      console.error(c.err(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+    if (responseText && !responseText.endsWith('\n')) process.stdout.write('\n');
+    process.exit(hadError ? 1 : 0);
+  });
+
 // ── IMAGINE ────────────────────────────────────────────────────
 program
   .command('imagine <prompt>')

package/lib/agent.js

@@ -176,6 +176,19 @@ function parseWriteTags(text) {
   while ((m = docxRe.exec(text)) !== null) {
     calls.push({ raw: m[0], offset: m.index, name: 'file_write_docx', args: { path: m[1], title: m[2] || undefined, content: m[3] } });
   }
+  // <edit path="..." [all="true"]>  <<<<<<< SEARCH … ======= … >>>>>>> REPLACE  </edit>
+  // Conflict-marker form so multiline code needs no JSON escaping.
+  const editRe = /<edit\s+path="([^"]+)"((?:\s+\w+="[^"]*")*)\s*>([\s\S]*?)<\/edit>/g;
+  while ((m = editRe.exec(text)) !== null) {
+    const body  = m[3];
+    const split = body.match(/<{3,}\s*SEARCH\s*\r?\n([\s\S]*?)\r?\n={3,}[ \t]*\r?\n([\s\S]*?)\r?\n>{3,}\s*REPLACE/);
+    if (!split) continue;
+    const all = /\ball="?(true|1|yes)"?/i.test(m[2]);
+    calls.push({
+      raw: m[0], offset: m.index, name: 'file_edit',
+      args: { path: m[1], old_string: split[1], new_string: split[2], replace_all: all || undefined },
+    });
+  }
   return calls;
 }
 
@@ -212,12 +225,14 @@ function stripToolTags(text) {
   out = out.replace(new RegExp(`<(?:${namesPattern})[^>]*>[\\s\\S]*?<\\/(?:${namesPattern})>`, 'gi'), '');
   // Self-closing or unclosed: <tool_name attr="val" />  or  <tool_name attr="val">
   out = out.replace(new RegExp(`<(?:${namesPattern})(?:\\s[^>]*)?\\s*/?>`, 'gi'), '');
+  // Tag-form file ops — never surface their bodies as chat text
+  out = out.replace(/<(write|append|docx|edit)\s+[^>]*>[\s\S]*?<\/\1>/gi, '');
   return out.trim();
 }
 
 // ── Main agent loop ───────────────────────────────────────────
 
-const CONFIRM_TOOLS = new Set(['run_command', 'file_delete', 'file_write']);
+const CONFIRM_TOOLS = new Set(['run_command', 'file_delete', 'file_write', 'file_edit']);
 
 async function runAgent({ messages, model, uncensored, cwd, projectContext, images, send, confirm, signal }) {
   const token = getToken();

package/lib/tools.js

@@ -47,6 +47,51 @@ function formatSize(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+// Directories never worth walking for search/glob
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.next', 'dist', 'build',
+  '.venv', 'venv', '.cache', 'coverage', '.nyc_output', 'vendor',
+  '.idea', '.vscode', 'bin/obj', 'obj', '.gradle', 'target',
+]);
+
+// Minimal glob → RegExp.  Supports **  *  ?  matched against a
+// forward-slash relative path.  Anchored full-string.
+function globToRegExp(glob) {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === '*') {
+      if (glob[i + 1] === '*') {           // ** → any depth (incl. slashes)
+        re += '.*';
+        i++;
+        if (glob[i + 1] === '/') i++;      // swallow the slash after **
+      } else {
+        re += '[^/]*';                     // * → within one path segment
+      }
+    } else if (ch === '?')                 re += '[^/]';
+    else if ('.+^${}()|[]\\'.includes(ch)) re += '\\' + ch;
+    else                                   re += ch;
+  }
+  return new RegExp('^' + re + '$', 'i');
+}
+
+// Recursively collect files under `root`, skipping SKIP_DIRS and oversized files.
+function walkFiles(root, onFile, budget = { left: 20000 }) {
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (budget.left <= 0) return;
+    const full = path.join(root, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name) || e.name.startsWith('.git')) continue;
+      walkFiles(full, onFile, budget);
+    } else {
+      budget.left--;
+      onFile(full);
+    }
+  }
+}
+
 // ── Tool implementations ──────────────────────────────────────
 
 const TOOLS = {
@@ -91,6 +136,103 @@ const TOOLS = {
     };
   },
 
+  async file_edit({ path: filePath, old_string, new_string, replace_all }, { cwd }) {
+    if (!filePath)              throw new Error('"path" is required');
+    if (old_string === undefined) throw new Error('"old_string" is required');
+    if (new_string === undefined) throw new Error('"new_string" is required');
+    if (old_string === new_string) throw new Error('old_string and new_string are identical — nothing to change');
+    const resolved = resolvePath(filePath, cwd);
+    if (!fs.existsSync(resolved)) throw new Error(`Not found: ${filePath} — use file_write to create a new file`);
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory())       throw new Error(`"${filePath}" is a directory`);
+    if (stat.size > MAX_FILE_SIZE) throw new Error(`File too large (${formatSize(stat.size)}, max 500KB)`);
+
+    const content = fs.readFileSync(resolved, 'utf8');
+    const first   = content.indexOf(old_string);
+    if (first === -1) throw new Error(`old_string not found in ${filePath} — it must match the file exactly, including whitespace and indentation`);
+
+    let updated, count;
+    if (replace_all) {
+      count   = content.split(old_string).length - 1;
+      updated = content.split(old_string).join(new_string);
+    } else {
+      if (content.indexOf(old_string, first + old_string.length) !== -1) {
+        throw new Error(`old_string appears multiple times in ${filePath} — add more surrounding context to make it unique, or pass "replace_all": true`);
+      }
+      count   = 1;
+      updated = content.slice(0, first) + new_string + content.slice(first + old_string.length);
+    }
+    fs.writeFileSync(resolved, updated, 'utf8');
+    const delta = (new_string.split('\n').length) - (old_string.split('\n').length);
+    return {
+      output:  `Edited ${filePath} — ${count} replacement${count !== 1 ? 's' : ''}${delta ? ` (${delta > 0 ? '+' : ''}${delta} lines)` : ''}`,
+      summary: `${count}× in ${path.basename(filePath)}`,
+    };
+  },
+
+  async file_search({ pattern, path: searchPath = '.', glob, ignore_case, max_results }, { cwd }) {
+    if (!pattern) throw new Error('"pattern" is required');
+    let re;
+    try { re = new RegExp(pattern, ignore_case ? 'i' : ''); }
+    catch (e) { throw new Error(`Invalid regex pattern: ${e.message}`); }
+    const root = resolvePath(searchPath, cwd);
+    if (!fs.existsSync(root)) throw new Error(`Not found: ${searchPath}`);
+    const cap    = Math.min(max_results || 100, 300);
+    const globRe = glob ? globToRegExp(glob.includes('/') ? glob : '**/' + glob) : null;
+    const hits   = [];
+    let filesMatched = new Set();
+
+    const scanFile = (full) => {
+      if (hits.length >= cap) return;
+      const rel = path.relative(cwd, full).replace(/\\/g, '/');
+      if (globRe && !globRe.test(rel) && !globRe.test(path.basename(full))) return;
+      let stat; try { stat = fs.statSync(full); } catch { return; }
+      if (stat.size > MAX_FILE_SIZE) return;
+      let text; try { text = fs.readFileSync(full, 'utf8'); } catch { return; }
+      if (text.indexOf('\x00') !== -1) return; // skip binary files
+      const lines = text.split('\n');
+      for (let i = 0; i < lines.length && hits.length < cap; i++) {
+        re.lastIndex = 0;
+        if (re.test(lines[i])) {
+          filesMatched.add(rel);
+          hits.push(`${rel}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+        }
+      }
+    };
+
+    if (fs.statSync(root).isDirectory()) walkFiles(root, scanFile);
+    else scanFile(root);
+
+    if (!hits.length) return { output: `No matches for /${pattern}/${glob ? ` in ${glob}` : ''}`, summary: '0 matches' };
+    const more = hits.length >= cap ? `\n… (capped at ${cap} matches)` : '';
+    return {
+      output:  hits.join('\n') + more,
+      summary: `${hits.length} match${hits.length !== 1 ? 'es' : ''} in ${filesMatched.size} file${filesMatched.size !== 1 ? 's' : ''}`,
+    };
+  },
+
+  async file_glob({ pattern, path: searchPath = '.' }, { cwd }) {
+    if (!pattern) throw new Error('"pattern" is required');
+    const root = resolvePath(searchPath, cwd);
+    if (!fs.existsSync(root)) throw new Error(`Not found: ${searchPath}`);
+    const globRe  = globToRegExp(pattern.includes('/') ? pattern : '**/' + pattern);
+    const results = [];
+    walkFiles(root, (full) => {
+      const rel = path.relative(root, full).replace(/\\/g, '/');
+      if (globRe.test(rel) || globRe.test(path.basename(full))) {
+        let mtime = 0; try { mtime = fs.statSync(full).mtimeMs; } catch {}
+        results.push({ rel: path.relative(cwd, full).replace(/\\/g, '/'), mtime });
+      }
+    });
+    results.sort((a, b) => b.mtime - a.mtime);
+    const top = results.slice(0, 200);
+    const more = results.length > top.length ? `\n… and ${results.length - top.length} more` : '';
+    return {
+      output:  top.length ? top.map(r => '  ' + r.rel).join('\n') + more : `No files match "${pattern}"`,
+      summary: `${results.length} file${results.length !== 1 ? 's' : ''} match "${pattern}"`,
+    };
+  },
+
   async file_list({ path: dirPath = '.' }, { cwd }) {
     const resolved = resolvePath(dirPath, cwd);
     if (!fs.existsSync(resolved)) throw new Error(`Not found: ${dirPath}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prior-cli",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "description": "Prior Network AI — command-line interface",
   "author": "Prior Network",
   "homepage": "https://priornetwork.com",