prior-cli 1.0.0 → 1.1.1

package/bin/prior.js

@@ -12,6 +12,7 @@ const { version } = require('../package.json');
 const api = require('../lib/api');
 const { renderMarkdown } = require('../lib/render');
 const { getToken, getUsername, saveAuth, clearAuth } = require('../lib/config');
+const { runAgent } = require('../lib/agent');
 
 // ── Theme ──────────────────────────────────────────────────────
 const THEME = '#9CE2D4';
@@ -297,7 +298,7 @@ async function loginViaBrowser() {
 
   // Long-poll the CLI backend until browser completes login (3 min timeout handled server-side)
   const fetch = require('node-fetch');
-  const res = await fetch(`http://127.0.0.1:7100/wait?state=${state}`, {
+  const res = await fetch(`https://prior.ngrok.app/cli-backend/wait?state=${state}`, {
     timeout: 185000,
   });
 
@@ -365,13 +366,6 @@ async function startChat(opts = {}) {
 
   const user = getUsername();
 
-  // Check if agent backend is running
-  spinStart('connecting…');
-  const backendHealth = await api.checkBackend();
-  spinStop();
-
-  const agentMode = !!backendHealth;
-
   console.clear();
   banner();
   console.log(DIVIDER);
@@ -386,12 +380,7 @@ async function startChat(opts = {}) {
     c.muted(`  ·  ${modelLabel}`)
   );
   console.log(c.muted(`  ${cwdShort}`));
-
-  if (agentMode) {
-    console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· file  web  shell  image  prior-network'));
-  } else {
-    console.log(c.warn('  ◎') + c.muted('  Basic mode  ') + c.dim('· run prior-cli-backend for agent mode'));
-  }
+  console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· file  web  shell  image  prior-network'));
 
   if (opts.uncensored) console.log(c.warn('  ⚠  Uncensored mode active'));
   console.log(DIVIDER);
@@ -595,7 +584,6 @@ async function startChat(opts = {}) {
               console.log(`  ${c.brand('▸')} ${c.bold(name.padEnd(16))} ${c.muted(desc)}`);
             });
             console.log('');
-            if (!agentMode) console.log(c.warn('  ⚠  Backend offline — start prior-cli-backend to enable\n'));
             return loop();
 
           case '/learn': {
@@ -677,10 +665,13 @@ Keep it under 350 words. Write prior.md now.`;
             let learnTextBuffer = '';
 
             try {
-              await api.agentChat(
-                [{ role: 'user', content: learnPrompt }],
-                { model: currentModel, uncensored, cwd: process.cwd() },
-                ev => {
+              await runAgent({
+                messages:       [{ role: 'user', content: learnPrompt }],
+                model:          currentModel,
+                uncensored,
+                cwd:            process.cwd(),
+                projectContext: null,
+                send: ev => {
                   switch (ev.type) {
                     case 'thinking':   spinStart('writing…'); break;
                     case 'tool_start':
@@ -697,8 +688,8 @@ Keep it under 350 words. Write prior.md now.`;
                     case 'done': spinStop(); break;
                     case 'error': spinStop(); console.error(c.err(`  ✗ ${ev.message}`)); break;
                   }
-                }
-              );
+                },
+              });
 
               // Text fallback: if model returned markdown content but didn't use write tag
               if (!fs.existsSync(priorMdPath) && learnTextBuffer.length > 80) {
@@ -774,20 +765,21 @@ Keep it under 350 words. Write prior.md now.`;
       msgCount++;
       console.log('');
 
-      if (agentMode) {
-        // ── Agent mode: full tool loop ──────────────────────
-        let responseText      = '';
-        let responseStarted   = false;
-        let _progressStarted  = false;
-        const _thinkStart     = Date.now();
+      {
+        let responseText     = '';
+        let _progressStarted = false;
+        const _thinkStart    = Date.now();
 
         spinStart('thinking…');
 
         try {
-          await api.agentChat(
-            [...chatHistory, { role: 'user', content: input }],
-            { model: currentModel, uncensored, cwd: process.cwd(), projectContext },
-            ev => {
+          await runAgent({
+            messages:       [...chatHistory, { role: 'user', content: input }],
+            model:          currentModel,
+            uncensored,
+            cwd:            process.cwd(),
+            projectContext,
+            send: ev => {
               switch (ev.type) {
 
                 case 'thinking':
@@ -828,13 +820,12 @@ Keep it under 350 words. Write prior.md now.`;
 
                 case 'text': {
                   spinStop();
-                  const rendered = renderMarkdown(ev.content);
+                  const rendered  = renderMarkdown(ev.content);
                   const thinkTime = elapsed(Date.now() - _thinkStart);
                   console.log(c.brand('  Prior  ') + c.muted(`·  ${timeNow()}  ·  ${thinkTime}`));
                   console.log('');
                   console.log(rendered);
                   responseText += ev.content;
-                  responseStarted = true;
                   break;
                 }
 
@@ -848,33 +839,17 @@ Keep it under 350 words. Write prior.md now.`;
                   console.error(c.err(`  ✗ ${ev.message}`));
                   break;
               }
-            }
-          );
+            },
+          });
         } catch (err) {
           spinStop();
           console.error(c.err(`  ✗ ${err.message}`));
         }
 
-        // Update history
         chatHistory.push({ role: 'user', content: input });
         if (responseText) chatHistory.push({ role: 'assistant', content: responseText });
 
         process.stdout.write('\n');
-
-      } else {
-        // ── Basic mode: direct API, no tools ───────────────
-        process.stdout.write(c.brand('  Prior  ') + c.muted('· '));
-
-        try {
-          await api.generate(input, { model: currentModel, uncensored }, chunk => {
-            process.stdout.write(chunk);
-          });
-        } catch (err) {
-          process.stdout.write('\n');
-          console.error(c.err(`  ✗ ${err.message}`));
-        }
-
-        process.stdout.write('\n\n');
       }
 
       loop();

package/lib/agent.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const fetch = require('node-fetch');
+const { executeTool, TOOL_NAMES } = require('./tools');
+const { buildSystemPrompt } = require('./systemPrompt');
+const { getToken, getUsername } = require('./config');
+
+const CLI_BASE  = 'https://prior.ngrok.app/cli-backend';
+const PRIOR_BASE = 'https://prior.ngrok.app';
+const MAX_ITER   = 14;
+
+// ── Single inference call (server just runs Ollama + returns) ─
+
+async function infer(messages, model, token) {
+  const res = await fetch(`${CLI_BASE}/api/infer`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body:    JSON.stringify({ messages, model, token }),
+    timeout: 120000,
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Server error: HTTP ${res.status}`);
+  }
+  return await res.json(); // { content, promptTokens, completionTokens }
+}
+
+// ── Token usage tracking ──────────────────────────────────────
+
+async function trackTokenUsage(token, promptTokens, completionTokens) {
+  if (!token || (!promptTokens && !completionTokens)) return;
+  try {
+    await fetch(`${PRIOR_BASE}/prior/api/user/token-usage`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+      body:    JSON.stringify({ promptTokens, completionTokens }),
+      timeout: 5000,
+    });
+  } catch { /* non-fatal */ }
+}
+
+// ── Tool call parsers (mirror server-side logic) ──────────────
+
+function fixJsonLiterals(str) {
+  let result = '';
+  let inString = false;
+  let escaped  = false;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (escaped)                { result += ch; escaped = false; continue; }
+    if (ch === '\\' && inString) { result += ch; escaped = true; continue; }
+    if (ch === '"')              { inString = !inString; result += ch; continue; }
+    if (inString) {
+      if      (ch === '\n') { result += '\\n'; continue; }
+      else if (ch === '\r') { result += '\\r'; continue; }
+      else if (ch === '\t') { result += '\\t'; continue; }
+    }
+    result += ch;
+  }
+  return result;
+}
+
+function parseToolCalls(text) {
+  const calls = [];
+
+  // Primary: <tool>{"name":"X","args":{...}}</tool>
+  const re = /<tool>([\s\S]*?)<\/tool>/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    try {
+      const fixed  = fixJsonLiterals(m[1].trim());
+      const parsed = JSON.parse(fixed);
+      if (parsed && typeof parsed.name === 'string') {
+        const { name, args, ...rest } = parsed;
+        calls.push({ raw: m[0], offset: m.index, name, args: args || (Object.keys(rest).length > 0 ? rest : {}) });
+      }
+    } catch { /* skip */ }
+  }
+
+  // Fallback: <tool_name>{...}</tool_name>
+  for (const name of TOOL_NAMES) {
+    const fbRe = new RegExp(`<${name}>([\\s\\S]*?)<\\/${name}>`, 'g');
+    let fm;
+    while ((fm = fbRe.exec(text)) !== null) {
+      const alreadyCaptured = calls.some(c => fm.index >= c.offset && fm.index < c.offset + c.raw.length);
+      if (alreadyCaptured) continue;
+      try {
+        const fixed  = fixJsonLiterals(fm[1].trim());
+        const parsed = JSON.parse(fixed);
+        const { args, ...rest } = parsed || {};
+        calls.push({ raw: fm[0], offset: fm.index, name, args: args || (parsed && Object.keys(rest).length > 0 ? rest : {}) });
+      } catch { /* skip */ }
+    }
+  }
+
+  return calls;
+}
+
+function parseWriteTags(text) {
+  const calls = [];
+  for (const { tag, name } of [
+    { tag: 'write',  name: 'file_write'  },
+    { tag: 'append', name: 'file_append' },
+  ]) {
+    const re = new RegExp(`<${tag}\\s+path="([^"]+)"[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'g');
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      calls.push({ raw: m[0], offset: m.index, name, args: { path: m[1], content: m[2] } });
+    }
+  }
+  // <docx path="..." title="...">content</docx>
+  const docxRe = /<docx\s+path="([^"]+)"(?:\s+title="([^"]*)")?[^>]*>([\s\S]*?)<\/docx>/g;
+  let m;
+  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] } });
+  }
+  return calls;
+}
+
+function stripThink(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+}
+
+// ── Main agent loop ───────────────────────────────────────────
+
+async function runAgent({ messages, model, uncensored, cwd, projectContext, send }) {
+  const token    = getToken();
+  const username = getUsername() || 'user';
+  const sysPrompt = buildSystemPrompt(username, cwd, uncensored, projectContext);
+
+  const history = [
+    { role: 'system', content: sysPrompt },
+    ...messages,
+  ];
+
+  let totalPromptTokens     = 0;
+  let totalCompletionTokens = 0;
+
+  for (let iter = 0; iter < MAX_ITER; iter++) {
+
+    send({ type: 'thinking' });
+
+    let result;
+    try {
+      result = await infer(history, model || 'qwen3.5:4b', token);
+    } catch (err) {
+      await trackTokenUsage(token, totalPromptTokens, totalCompletionTokens);
+      send({ type: 'error', message: err.message });
+      send({ type: 'done' });
+      return;
+    }
+
+    totalPromptTokens     += result.promptTokens     || 0;
+    totalCompletionTokens += result.completionTokens || 0;
+
+    const raw     = result.content;
+    const cleaned = stripThink(raw)
+      .replace(/<tool_result[\s\S]*?<\/tool_result>/gi, '')
+      .trim();
+
+    const calls = [
+      ...parseToolCalls(cleaned),
+      ...parseWriteTags(cleaned),
+    ].sort((a, b) => a.offset - b.offset);
+
+    // ── No tool calls → final answer ──────────────────────────
+    if (calls.length === 0) {
+      await trackTokenUsage(token, totalPromptTokens, totalCompletionTokens);
+      send({ type: 'text', content: cleaned });
+      send({ type: 'done' });
+      return;
+    }
+
+    // ── Text before first tool call ───────────────────────────
+    const textBefore = cleaned.slice(0, calls[0].offset).trim();
+    if (textBefore) send({ type: 'text', content: textBefore });
+
+    history.push({ role: 'assistant', content: raw });
+
+    // ── Execute each tool locally ─────────────────────────────
+    const resultParts = [];
+    for (const call of calls) {
+      send({ type: 'tool_start', name: call.name, args: call.args });
+      try {
+        const toolResult = await executeTool(call.name, call.args, { cwd, token, send });
+        send({ type: 'tool_done', name: call.name, summary: toolResult.summary });
+        resultParts.push(`<tool_result name="${call.name}">\n${toolResult.output}\n</tool_result>`);
+      } catch (err) {
+        send({ type: 'tool_error', name: call.name, error: err.message });
+        resultParts.push(`<tool_result name="${call.name}">\nERROR: ${err.message}\n</tool_result>`);
+      }
+    }
+
+    history.push({ role: 'user', content: resultParts.join('\n\n') });
+  }
+
+  await trackTokenUsage(token, totalPromptTokens, totalCompletionTokens);
+  send({ type: 'error', message: 'Reached maximum tool iterations.' });
+  send({ type: 'done' });
+}
+
+module.exports = { runAgent };

package/lib/api.js

@@ -6,6 +6,22 @@ const { getToken } = require('./config');
 const BASE     = 'https://prior.ngrok.app';
 const CLI_BASE = 'https://prior.ngrok.app/cli-backend';
 
+// ── Infer — single AI call, returns { content, promptTokens, completionTokens }
+
+async function infer(messages, model, token) {
+  const res = await fetch(`${CLI_BASE}/api/infer`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body:    JSON.stringify({ messages, model, token }),
+    timeout: 120000,
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Server error: HTTP ${res.status}`);
+  }
+  return await res.json();
+}
+
 function authHeaders(extra = {}) {
   const token = getToken();
   const h = { 'Content-Type': 'application/json', ...extra };
@@ -26,66 +42,6 @@ async function login(username, password) {
   return data;
 }
 
-// ── CLI Backend ───────────────────────────────────────────────
-
-async function checkBackend() {
-  try {
-    const res = await fetch(`${CLI_BASE}/health`, { timeout: 3000 });
-    if (!res.ok) return null;
-    return await res.json();
-  } catch {
-    return null;
-  }
-}
-
-// Agent chat — SSE stream. Calls onEvent(event) for each SSE event.
-// Events: { type: 'thinking' | 'tool_start' | 'tool_done' | 'tool_error' |
-//           'response_start' | 'response_pause' | 'text' | 'error' | 'done' }
-async function agentChat(messages, opts = {}, onEvent) {
-  const token = getToken();
-  const res = await fetch(`${CLI_BASE}/api/chat`, {
-    method:  'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      messages,
-      model:         opts.model         || undefined,
-      uncensored:    opts.uncensored    || false,
-      cwd:           opts.cwd           || process.cwd(),
-      projectContext: opts.projectContext || undefined,
-      token,
-    }),
-    timeout: 300000,
-  });
-
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({}));
-    throw new Error(err.error || `HTTP ${res.status}`);
-  }
-
-  return new Promise((resolve, reject) => {
-    let buf = '';
-
-    res.body.on('data', chunk => {
-      buf += chunk.toString();
-      const lines = buf.split('\n');
-      buf = lines.pop();
-
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) continue;
-        const raw = line.slice(6).trim();
-        if (!raw) continue;
-        try {
-          const event = JSON.parse(raw);
-          onEvent(event);
-          if (event.type === 'done' || event.type === 'error') resolve();
-        } catch { /* skip malformed SSE */ }
-      }
-    });
-
-    res.body.on('end',   resolve);
-    res.body.on('error', reject);
-  });
-}
 
 // ── Direct AI (fallback, no agent) ───────────────────────────
 
@@ -236,8 +192,7 @@ async function search(query) {
 }
 
 module.exports = {
-  login,
-  checkBackend, agentChat,
+  login, infer,
   generate,
   generateImage, pollImageProgress, downloadImage,
   getModels, getChats, getUsage, getWeather, search,

package/lib/systemPrompt.js

@@ -0,0 +1,81 @@
+'use strict';
+
+function buildSystemPrompt(username, cwd, uncensored, projectContext) {
+  const date = new Date().toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
+
+  return `You are Prior, an AI assistant created by Niceguygamer (Euwin). Be direct, confident, and helpful. Never say "according to my database" or "based on my training data."
+
+IMPORTANT: Do NOT assume the person talking to you is Euwin. Euwin is the creator/developer — the user may be anyone.
+
+PERSONALITY: Dry wit, genuine character. One short off-script remark when it genuinely fits — don't force it.
+
+Origins: Started as a school bot for the BEN friend group. Originally a Jollibee prank bot.
+
+---
+
+Signed-in user: @${username} | CWD: ${cwd} | ${date}
+
+## Tools
+
+CRITICAL: When you need to use a tool, you MUST output the tool call immediately. Do NOT say "I'll write that" or "Writing that now..." — just call the tool directly. Describing an action instead of doing it is wrong.
+
+Correct tool call format — output this exactly, on its own line:
+<tool>{"name":"TOOL_NAME","args":{"key":"value"}}</tool>
+
+You will then receive:
+<tool_result name="TOOL_NAME">result</tool_result>
+
+### Writing / Appending Files (ALWAYS use this format — never put file content in JSON)
+<write path="relative/or/C:/absolute/path.ext">
+file content goes here — no escaping needed
+</write>
+
+<append path="path/to/file.txt">
+content to add
+</append>
+
+### Other Tools (JSON format)
+<tool>{"name":"TOOL_NAME","args":{"key":"value"}}</tool>
+
+Available tools:
+- file_read       args: {"path":"string"}
+- file_list       args: {"path":"string"}
+- file_delete     args: {"path":"string"}
+- file_write_docx — Word document. Use this tag format (NEVER put content in JSON):
+  <docx path="C:/path/to/file.docx" title="Optional Title">
+  # Heading 1
+  ## Heading 2
+  Normal paragraph with **bold** and *italic* supported.
+  </docx>
+- web_search      args: {"query":"string"}
+- url_fetch       args: {"url":"string"}
+- run_command     args: {"command":"string"}
+- clipboard_read  args: {}
+- clipboard_write args: {"text":"string"}
+- generate_image  args: {"prompt":"string","width":896,"height":896,"steps":20}
+- prior_feed      args: {}
+- prior_profile   args: {}
+
+### Image generation notes
+- generate_image queues and polls automatically — it can take 1-3 minutes, this is normal
+- Always confirm where the image was saved after it completes
+- If user says "generate X" or "create an image of X", use generate_image immediately
+- Image saves to the current working directory by default; user can ask to move it after
+- When calling generate_image, extract only the core subject/description the user gave. Strip conversational filler ("can you", "please", "I want", "make me", "draw me", etc.). Do NOT add style tags, quality boosters, or extra descriptors like "high detail", "cinematic", "4k", "in motion", "sleek", etc. Pass only what the user described.
+  Examples:
+    "generate car"                    → prompt: "car"
+    "can you make me a sunset"        → prompt: "sunset"
+    "draw a cat sitting on a roof"    → prompt: "cat sitting on a roof"
+    "I want to see a dragon flying"   → prompt: "dragon flying"
+
+${projectContext ? `### Project Context (prior.md)\n${projectContext}\n` : ''}### Rules
+- ACT with tools, don't narrate. If asked to create a file — create it immediately.
+- If the user asks for a Word document (.docx), use the <docx> tag format above — NEVER use file_write for .docx.
+- For file_write / file_append ALWAYS use the <write>/<append> tags above — NEVER put file content inside JSON.
+- Paths relative to CWD unless absolute (e.g. C:/Users/ADMIN/Downloads/file.py)
+- After tool results, give a short confirmation
+- Never output <tool_result> yourself — that comes from the system
+${uncensored ? '- Uncensored mode active\n' : ''}`;
+}
+
+module.exports = { buildSystemPrompt };

package/lib/tools.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const fetch    = require('node-fetch');
+
+const CLI_BASE   = 'https://prior.ngrok.app/cli-backend';
+const PRIOR_BASE = 'https://prior.ngrok.app';
+const MAX_FILE_SIZE = 500 * 1024; // 500 KB
+
+const BLOCKED_PATTERNS = [
+  'rm -rf /',
+  'del /s /q c:\\',
+  'format c:',
+  'fdisk',
+  ':(){:|:&};:',
+  'dd if=',
+  'mkfs',
+  'bcdedit /delete',
+  'reg delete hklm',
+];
+
+function resolvePath(inputPath, cwd) {
+  if (!inputPath) return cwd;
+  if (/^[a-zA-Z]:[/\\]/.test(inputPath) || path.isAbsolute(inputPath)) return inputPath;
+  return path.resolve(cwd, inputPath);
+}
+
+function execAsync(command, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const lower = command.toLowerCase();
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (lower.includes(pattern)) return reject(new Error(`Blocked: command contains "${pattern}"`));
+    }
+    exec(command, { timeout: 20000, maxBuffer: 4 * 1024 * 1024, ...opts }, (err, stdout, stderr) => {
+      if (err && !stdout && !stderr) return reject(new Error(err.message));
+      resolve({ stdout: (stdout || '').trim(), stderr: (stderr || '').trim() });
+    });
+  });
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// ── Tool implementations ──────────────────────────────────────
+
+const TOOLS = {
+
+  async file_read({ path: filePath }, { cwd }) {
+    if (!filePath) throw new Error('"path" is required');
+    const resolved = resolvePath(filePath, cwd);
+    if (!fs.existsSync(resolved)) throw new Error(`Not found: ${filePath}`);
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory()) throw new Error(`"${filePath}" is a directory — use file_list`);
+    if (stat.size > MAX_FILE_SIZE) throw new Error(`File too large (${formatSize(stat.size)}, max 500KB)`);
+    const content = fs.readFileSync(resolved, 'utf8');
+    return {
+      output:  content,
+      summary: `${content.split('\n').length} lines · ${formatSize(stat.size)}`,
+    };
+  },
+
+  async file_write({ path: filePath, content }, { cwd }) {
+    if (!filePath)             throw new Error('"path" is required');
+    if (content === undefined) throw new Error('"content" is required');
+    const resolved = resolvePath(filePath, cwd);
+    const dir = path.dirname(resolved);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(resolved, content, 'utf8');
+    const bytes = Buffer.byteLength(content, 'utf8');
+    return {
+      output:  `Written: ${filePath} (${formatSize(bytes)})`,
+      summary: `${formatSize(bytes)} → ${path.basename(filePath)}`,
+    };
+  },
+
+  async file_append({ path: filePath, content }, { cwd }) {
+    if (!filePath)             throw new Error('"path" is required');
+    if (content === undefined) throw new Error('"content" is required');
+    const resolved = resolvePath(filePath, cwd);
+    fs.appendFileSync(resolved, content, 'utf8');
+    const bytes = Buffer.byteLength(content, 'utf8');
+    return {
+      output:  `Appended ${formatSize(bytes)} to ${filePath}`,
+      summary: `+${formatSize(bytes)} to ${path.basename(filePath)}`,
+    };
+  },
+
+  async file_list({ path: dirPath = '.' }, { cwd }) {
+    const resolved = resolvePath(dirPath, cwd);
+    if (!fs.existsSync(resolved)) throw new Error(`Not found: ${dirPath}`);
+    if (!fs.statSync(resolved).isDirectory()) throw new Error(`Not a directory: ${dirPath}`);
+    const entries = fs.readdirSync(resolved, { withFileTypes: true });
+    const lines = entries.map(e => {
+      if (e.isDirectory()) return `  📁  ${e.name}/`;
+      try {
+        const size = fs.statSync(path.join(resolved, e.name)).size;
+        return `  📄  ${e.name}  ${formatSize(size)}`;
+      } catch {
+        return `  📄  ${e.name}`;
+      }
+    });
+    return {
+      output:  lines.join('\n') || '(empty directory)',
+      summary: `${entries.length} items in ${dirPath}`,
+    };
+  },
+
+  async file_delete({ path: filePath }, { cwd }) {
+    if (!filePath) throw new Error('"path" is required');
+    const resolved = resolvePath(filePath, cwd);
+    if (!fs.existsSync(resolved)) throw new Error(`Not found: ${filePath}`);
+    if (fs.statSync(resolved).isDirectory()) throw new Error('Use run_command to remove directories');
+    fs.unlinkSync(resolved);
+    return {
+      output:  `Deleted: ${filePath}`,
+      summary: path.basename(filePath),
+    };
+  },
+
+  async file_write_docx({ path: filePath, content, title }, { cwd }) {
+    if (!filePath)             throw new Error('"path" is required');
+    if (content === undefined) throw new Error('"content" is required');
+    const { Document, Packer, Paragraph, TextRun, HeadingLevel } = require('docx');
+    const resolved = resolvePath(filePath, cwd);
+    const dir = path.dirname(resolved);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const lines    = content.split('\n');
+    const children = [];
+    if (title) children.push(new Paragraph({ text: title, heading: HeadingLevel.TITLE }));
+
+    for (const line of lines) {
+      if      (line.startsWith('# '))   children.push(new Paragraph({ text: line.slice(2),  heading: HeadingLevel.HEADING_1 }));
+      else if (line.startsWith('## '))  children.push(new Paragraph({ text: line.slice(3),  heading: HeadingLevel.HEADING_2 }));
+      else if (line.startsWith('### ')) children.push(new Paragraph({ text: line.slice(4),  heading: HeadingLevel.HEADING_3 }));
+      else if (line.trim() === '')      children.push(new Paragraph({ text: '' }));
+      else {
+        const runs  = [];
+        const parts = line.split(/(\*\*[^*]+\*\*|\*[^*]+\*)/g);
+        for (const part of parts) {
+          if      (part.startsWith('**') && part.endsWith('**')) runs.push(new TextRun({ text: part.slice(2, -2), bold: true }));
+          else if (part.startsWith('*')  && part.endsWith('*'))  runs.push(new TextRun({ text: part.slice(1, -1), italics: true }));
+          else if (part)                                          runs.push(new TextRun({ text: part }));
+        }
+        children.push(new Paragraph({ children: runs }));
+      }
+    }
+
+    const doc    = new Document({ sections: [{ children }] });
+    const buffer = await Packer.toBuffer(doc);
+    fs.writeFileSync(resolved, buffer);
+    return {
+      output:  `Word document saved: ${filePath} (${formatSize(buffer.length)})`,
+      summary: `${formatSize(buffer.length)} → ${path.basename(filePath)}`,
+    };
+  },
+
+  async web_search({ query }, { token }) {
+    if (!query) throw new Error('"query" is required');
+    const res  = await fetch(`${CLI_BASE}/api/web-search`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+      body:    JSON.stringify({ query }),
+      timeout: 15000,
+    });
+    if (!res.ok) throw new Error(`Web search error: HTTP ${res.status}`);
+    const data = await res.json();
+    if (!data.items || !data.items.length) return { output: 'No results found.', summary: '0 results' };
+    const results = data.items.map(item => {
+      const parts = [`**${item.title}**`, item.link];
+      if (item.snippet) parts.push(item.snippet);
+      return parts.join('\n');
+    });
+    return {
+      output:  results.join('\n\n'),
+      summary: `${results.length} results for "${query}"`,
+    };
+  },
+
+  async url_fetch({ url }, { token }) {
+    if (!url) throw new Error('"url" is required');
+    const res = await fetch(`${CLI_BASE}/api/url-fetch`, {
+      method:  'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      },
+      body:    JSON.stringify({ url }),
+      timeout: 30000,
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || `HTTP ${res.status}`);
+    }
+    const data     = await res.json();
+    const hostname = (() => { try { return new URL(url).hostname; } catch { return url; } })();
+    const content  = data.content || data.description || '(no readable content)';
+    const titleStr = data.title ? `# ${data.title}\n\n` : '';
+    return {
+      output:  (titleStr + content).slice(0, 8000),
+      summary: `${content.length} chars from ${hostname}`,
+    };
+  },
+
+  async clipboard_read() {
+    const { stdout } = await execAsync('powershell -command "Get-Clipboard"');
+    return {
+      output:  stdout || '(clipboard is empty)',
+      summary: `${stdout.length} chars from clipboard`,
+    };
+  },
+
+  async clipboard_write({ text }) {
+    if (!text && text !== '') throw new Error('"text" is required');
+    const escaped = text.replace(/'/g, "''");
+    await execAsync(`powershell -command "Set-Clipboard -Value '${escaped}'"`);
+    return {
+      output:  `Copied to clipboard (${text.length} chars)`,
+      summary: `${text.length} chars copied`,
+    };
+  },
+
+  async generate_image({ prompt, width, height, steps }, { cwd, token }) {
+    if (!prompt) throw new Error('"prompt" is required');
+    // Server handles queuing, polling, and watermarking — returns base64
+    const res = await fetch(`${CLI_BASE}/api/generate-image`, {
+      method:  'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      },
+      body:    JSON.stringify({ prompt, width: width || 896, height: height || 896, steps: steps || 20 }),
+      timeout: 360000,
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(err.error || err.message || `HTTP ${res.status}`);
+    }
+    const data = await res.json();
+    if (!data.filename || !data.data) throw new Error('Invalid response from image generation service');
+    const savePath = path.join(cwd, data.filename);
+    fs.writeFileSync(savePath, Buffer.from(data.data, 'base64'));
+    return {
+      output:  `Image saved to: ${savePath}`,
+      summary: savePath,
+    };
+  },
+
+  async run_command({ command }, { cwd }) {
+    if (!command) throw new Error('"command" is required');
+    const { stdout, stderr } = await execAsync(`cd /d "${cwd}" && ${command}`);
+    const output = [stdout, stderr].filter(Boolean).join('\n') || '(no output)';
+    return {
+      output,
+      summary: command.length > 60 ? command.slice(0, 57) + '…' : command,
+    };
+  },
+
+  async prior_feed({}, { token }) {
+    const res = await fetch(`${PRIOR_BASE}/network/api/posts`, {
+      headers: token ? { Authorization: `Bearer ${token}` } : {},
+      timeout: 8000,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data  = await res.json();
+    const posts = (data.posts || data || []).slice(0, 8);
+    if (!posts.length) return { output: 'No posts found.', summary: '0 posts' };
+    const lines = posts.map(p => {
+      const date = p.created_at ? new Date(p.created_at).toLocaleDateString() : '';
+      return `@${p.username || '?'}  ${date}\n${(p.content || '').slice(0, 200)}`;
+    });
+    return {
+      output:  lines.join('\n\n─────────────────────\n\n'),
+      summary: `${posts.length} posts`,
+    };
+  },
+
+  async prior_profile({}, { token }) {
+    const res = await fetch(`${PRIOR_BASE}/network/api/profile`, {
+      headers: token ? { Authorization: `Bearer ${token}` } : {},
+      timeout: 8000,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    const u    = data.user || data;
+    return {
+      output: [
+        `Username     : @${u.username || '?'}`,
+        `Display Name : ${u.display_name || u.username || '?'}`,
+        `Bio          : ${u.bio || '(none)'}`,
+        `Posts        : ${u.post_count   ?? 0}`,
+        `Friends      : ${u.friend_count ?? 0}`,
+        `Joined       : ${u.created_at ? new Date(u.created_at).toLocaleDateString() : 'unknown'}`,
+      ].join('\n'),
+      summary: `@${u.username || '?'}`,
+    };
+  },
+};
+
+async function executeTool(name, args, context) {
+  const fn = TOOLS[name];
+  if (!fn) throw new Error(`Unknown tool: "${name}"`);
+  return await fn(args || {}, context);
+}
+
+const TOOL_NAMES = Object.keys(TOOLS);
+
+module.exports = { executeTool, TOOL_NAMES };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prior-cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Prior Network AI — command-line interface",
   "bin": {
     "prior": "bin/prior.js"
@@ -11,6 +11,7 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
+    "docx": "^9.6.1",
     "node-fetch": "^2.7.0",
     "open": "^8.4.2"
   },