cowork-cli 2.1.0 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-cli",
-  "version": "2.1.0",
+  "version": "2.2.2",
   "description": "work with cowork",
   "bin": {
     "cwk": "bin/cli.js"
@@ -33,6 +33,7 @@
   "dependencies": {
     "dotenv": "^17.4.2",
     "ipaddr.js": "^2.4.0",
+    "node-html-parser": "^7.1.0",
     "openai": "^6.38.0"
   }
-}
+}

package/src/engine/models/BaseModel.js

@@ -121,20 +121,33 @@ export default class BaseModel {
         return response;
 
       } catch (err) {
-        const isTransient = [429, 500, 502, 503, 504].includes(err.status);
+        // Transient HTTP status codes (rate-limit, server errors)
+        const isHttpTransient = [429, 500, 502, 503, 504].includes(err.status);
+        // Transient Node.js-level network errors (flaky connections, DNS hiccups)
+        const TRANSIENT_NET_CODES = new Set([
+          'ECONNRESET',    // Connection forcibly closed by the remote side
+          'ETIMEDOUT',     // Connection or operation timed out
+          'ECONNREFUSED',  // Remote host actively refused the connection
+          'EAI_AGAIN',     // Temporary DNS resolution failure
+          'ENETUNREACH',   // Network is unreachable
+          'EHOSTUNREACH',  // Host is unreachable
+        ]);
+        const isNetTransient = TRANSIENT_NET_CODES.has(err.code);
+        const isTransient = isHttpTransient || isNetTransient;
+
         if (isTransient && retries < maxRetries) {
           retries++;
-          
+
           let delay = Math.pow(2, retries) * 1000;
-          
-          // 2. Adhere to Retry-After header if present
+
+          // 2. Adhere to Retry-After header if present (HTTP errors only)
           const retryAfter = err.headers?.['retry-after'];
           if (retryAfter) {
             const seconds = parseInt(retryAfter);
             if (!isNaN(seconds)) {
               delay = seconds * 1000;
             } else {
-              // Handle Date string
+              // Handle Date string format
               const retryDate = new Date(retryAfter);
               if (!isNaN(retryDate.getTime())) {
                 delay = Math.max(0, retryDate.getTime() - Date.now());
@@ -146,7 +159,9 @@ export default class BaseModel {
           const jitter = Math.random() * 500;
           const finalDelay = delay + jitter;
 
-          ui.update(`Error ${err.status}. Retrying in ${(finalDelay/1000).toFixed(1)}s`);
+          // Show a meaningful label: HTTP status or Node error code
+          const errLabel = err.status ?? err.code ?? 'Network error';
+          ui.update(`${errLabel}. Retrying in ${(finalDelay/1000).toFixed(1)}s`);
           await new Promise(resolve => setTimeout(resolve, finalDelay));
           ui.update('Thinking');
           continue;
@@ -184,7 +199,10 @@ export default class BaseModel {
           webSearch: 'searching web',
           findFile: 'finding',
           findDir: 'finding',
-          listTools: 'listing'
+          listTools: 'listing',
+          gitDiff: 'git diff',
+          gitLog: 'git log',
+          gitStatus: 'git status',
         };
 
         const label = toolLabels[name] || name;
@@ -197,6 +215,11 @@ export default class BaseModel {
         else if (name === 'webSearch') displayArg = `'${args.query}'`;
         else if (name === 'findFile' || name === 'findDir') displayArg = `'${args.pattern}' in ${args.dirPath || '.'}`;
         else if (name === 'readFileChunk') displayArg = `${args.filePath} [L${args.startLine}-${args.endLine}]`;
+        else if (name === 'gitDiff') {
+          const scope = args.staged ? 'staged' : 'unstaged';
+          displayArg = args.filePath ? `${scope} · ${args.filePath}` : scope;
+        }
+        else if (name === 'gitLog') displayArg = `last ${args.limit ?? 10} commits`;
         else displayArg = args.url || args.filePath || args.dirPath || args.path || args.pattern || JSON.stringify(args);
 
         // ui.start() handles terminal-aware truncation internally.

package/src/engine/tools/gitDiff.js

@@ -0,0 +1,76 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { safePath } from '../../utils/fsUtils.js';
+
+const execFileAsync = promisify(execFile);
+
+const MAX_LINES = 500;
+const DEFAULT_MAX_LINES = 300;
+const GIT_TIMEOUT_MS = 10_000;
+const GIT_MAX_BUFFER = 1024 * 1024; // 1 MB raw output cap
+
+/**
+ * Runs a git command safely using execFile (no shell — args are an array).
+ * @param {string[]} args  Git sub-command and flags.
+ * @param {string}   cwd   Working directory.
+ * @returns {Promise<{ok: boolean, output?: string, error?: string}>}
+ */
+async function runGit(args, cwd = process.cwd()) {
+  try {
+    const { stdout } = await execFileAsync('git', args, {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+    });
+    return { ok: true, output: stdout };
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return { ok: false, error: 'Error: Git is not installed or not found in PATH.' };
+    }
+    const msg = (err.stderr || err.message || '').trim();
+    return { ok: false, error: `Error: ${msg || 'Unknown git error.'}` };
+  }
+}
+
+/**
+ * gitDiff tool: Shows unstaged or staged file changes as a unified diff.
+ * @param {Object}  args
+ * @param {boolean} [args.staged=false]   If true, diffs the staging area (--staged).
+ * @param {string}  [args.filePath]       Limit diff to a specific file (validated with safePath).
+ * @param {number}  [args.maxLines=300]   Maximum output lines to return (max: 500).
+ */
+export default async function gitDiff({ staged = false, filePath, maxLines = DEFAULT_MAX_LINES }) {
+  // Clamp maxLines
+  const limit = Math.min(Math.max(1, maxLines), MAX_LINES);
+
+  // Build git args — all discrete, never shell-interpolated
+  const args = ['diff', '--no-color'];
+  if (staged) args.push('--staged');
+
+  // Validate and append optional path filter
+  if (filePath) {
+    let resolved;
+    try {
+      resolved = safePath(filePath);
+    } catch (err) {
+      return `Error: ${err.message}`;
+    }
+    args.push('--', resolved);
+  }
+
+  const result = await runGit(args);
+  if (!result.ok) return result.error;
+
+  const output = result.output.trim();
+  if (!output) {
+    return staged
+      ? 'No staged changes found.'
+      : 'No unstaged changes found. Working tree is clean.';
+  }
+
+  const lines = output.split('\n');
+  if (lines.length > limit) {
+    return lines.slice(0, limit).join('\n') + `\n\n[Warning: Truncated at ${limit} lines]`;
+  }
+  return output;
+}

package/src/engine/tools/gitLog.js

@@ -0,0 +1,60 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const MAX_LIMIT = 50;
+const DEFAULT_LIMIT = 10;
+const GIT_TIMEOUT_MS = 10_000;
+const GIT_MAX_BUFFER = 1024 * 1024; // 1 MB raw output cap
+
+/**
+ * Runs a git command safely using execFile (no shell — args are an array).
+ * @param {string[]} args  Git sub-command and flags.
+ * @param {string}   cwd   Working directory.
+ * @returns {Promise<{ok: boolean, output?: string, error?: string}>}
+ */
+async function runGit(args, cwd = process.cwd()) {
+  try {
+    const { stdout } = await execFileAsync('git', args, {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+    });
+    return { ok: true, output: stdout };
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return { ok: false, error: 'Error: Git is not installed or not found in PATH.' };
+    }
+    const msg = (err.stderr || err.message || '').trim();
+    return { ok: false, error: `Error: ${msg || 'Unknown git error.'}` };
+  }
+}
+
+/**
+ * gitLog tool: Returns recent commit history in a readable format.
+ * @param {Object}  args
+ * @param {number}  [args.limit=10]       Number of commits to retrieve (max: 50).
+ * @param {boolean} [args.oneline=false]  Compact single-line format per commit.
+ */
+export default async function gitLog({ limit = DEFAULT_LIMIT, oneline = false }) {
+  // Clamp limit
+  const count = Math.min(Math.max(1, limit), MAX_LIMIT);
+
+  const args = ['log', '--no-color', `-n`, String(count)];
+  if (oneline) {
+    args.push('--oneline');
+  } else {
+    // Human-readable multi-line format: hash | author | date | subject
+    args.push('--pretty=format:commit %H%nauthor: %an <%ae>%ndate:   %ad%n%n    %s%n%b%n---');
+    args.push('--date=short');
+  }
+
+  const result = await runGit(args);
+  if (!result.ok) return result.error;
+
+  const output = result.output.trim();
+  if (!output) return 'No commits found in this repository.';
+
+  return output;
+}

package/src/engine/tools/gitStatus.js

@@ -0,0 +1,92 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const GIT_TIMEOUT_MS = 10_000;
+const GIT_MAX_BUFFER = 1024 * 1024; // 1 MB raw output cap
+
+/**
+ * Runs a git command safely using execFile (no shell — args are an array).
+ * @param {string[]} args  Git sub-command and flags.
+ * @param {string}   cwd   Working directory.
+ * @returns {Promise<{ok: boolean, output?: string, error?: string}>}
+ */
+async function runGit(args, cwd = process.cwd()) {
+  try {
+    const { stdout } = await execFileAsync('git', args, {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+    });
+    return { ok: true, output: stdout };
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return { ok: false, error: 'Error: Git is not installed or not found in PATH.' };
+    }
+    const msg = (err.stderr || err.message || '').trim();
+    return { ok: false, error: `Error: ${msg || 'Unknown git error.'}` };
+  }
+}
+
+// Porcelain v1 two-character status codes → human description
+const STATUS_LABELS = {
+  M:  'modified',
+  A:  'added',
+  D:  'deleted',
+  R:  'renamed',
+  C:  'copied',
+  U:  'unmerged',
+  '?': 'untracked',
+  '!': 'ignored',
+};
+
+/**
+ * Parses `git status --porcelain` output into grouped sections.
+ * @param {string} raw  Raw porcelain output.
+ * @returns {string}    Formatted status string.
+ */
+function parsePorcelain(raw) {
+  if (!raw.trim()) return 'Working tree is clean. Nothing to report.';
+
+  const staged    = [];
+  const unstaged  = [];
+  const untracked = [];
+
+  for (const line of raw.split('\n')) {
+    if (!line) continue;
+
+    const x    = line[0]; // index (staged) status
+    const y    = line[1]; // worktree (unstaged) status
+    const file = line.slice(3);
+
+    if (x === '?' && y === '?') {
+      untracked.push(file);
+      continue;
+    }
+    if (x !== ' ' && x !== '?') {
+      staged.push(`  ${STATUS_LABELS[x] ?? x}  ${file}`);
+    }
+    if (y !== ' ' && y !== '?') {
+      unstaged.push(`  ${STATUS_LABELS[y] ?? y}  ${file}`);
+    }
+  }
+
+  const sections = [];
+  if (staged.length)    sections.push(`Staged changes:\n${staged.join('\n')}`);
+  if (unstaged.length)  sections.push(`Unstaged changes:\n${unstaged.join('\n')}`);
+  if (untracked.length) sections.push(`Untracked files:\n${untracked.map(f => `  ${f}`).join('\n')}`);
+
+  return sections.join('\n\n');
+}
+
+/**
+ * gitStatus tool: Shows the working tree status grouped into staged, unstaged, and untracked sections.
+ * No parameters — always operates on process.cwd().
+ */
+export default async function gitStatus() {
+  const result = await runGit(['status', '--porcelain']);
+  if (!result.ok) return result.error;
+
+  return parsePorcelain(result.output);
+}

package/src/engine/tools/index.js

@@ -10,6 +10,9 @@ import findFile from './findFile.js';
 import findDir from './findDir.js';
 import askUser from './askUser.js';
 import askConfirm from './askConfirm.js';
+import gitDiff from './gitDiff.js';
+import gitLog from './gitLog.js';
+import gitStatus from './gitStatus.js';
 
 export const toolDefinitions = [
   {
@@ -189,6 +192,49 @@ export const toolDefinitions = [
         required: ["question"]
       }
     }
+  },
+  {
+    type: "function",
+    function: {
+      name: "gitDiff",
+      description: "Show file changes as a unified diff. Use staged:true to see staged changes, or omit for unstaged changes. Optionally limit to a single file.",
+      parameters: {
+        type: "object",
+        properties: {
+          staged:   { type: "boolean", description: "If true, shows staged (index) changes. Default: false (unstaged)." },
+          filePath: { type: "string",  description: "Limit diff to this specific file path (optional)." },
+          maxLines: { type: "number",  description: "Maximum lines of diff output to return (default: 300, max: 500)." }
+        },
+        required: []
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "gitLog",
+      description: "Show recent commit history. Returns commit hash, author, date, and message.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit:   { type: "number",  description: "Number of commits to retrieve (default: 10, max: 50)." },
+          oneline: { type: "boolean", description: "If true, shows each commit as a compact single line. Default: false." }
+        },
+        required: []
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "gitStatus",
+      description: "Show the working tree status grouped into staged changes, unstaged changes, and untracked files.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }
   }
 ];
 
@@ -204,7 +250,10 @@ const toolImplementations = {
   findFile,
   findDir,
   askUser,
-  askConfirm
+  askConfirm,
+  gitDiff,
+  gitLog,
+  gitStatus,
 };
 
 /**

package/src/engine/tools/listTools.js

@@ -75,6 +75,24 @@ export default async function listTools() {
       usage: "askConfirm({ question: 'Should I proceed with deleting this file?' })",
       description: "Asks the user a yes/no question using an interactive toggle. Returns { confirmed: true } for yes, { confirmed: false } for no, or { confirmed: false, dismissed: true } on cancellation.",
       whenToUse: "When only a boolean decision is needed from the user. Prefer this over askUser for simple yes/no choices."
+    },
+    {
+      name: "gitDiff",
+      usage: "gitDiff({ staged: false, filePath: 'src/main.js', maxLines: 300 })",
+      description: "Shows file changes as a unified diff. Defaults to unstaged changes. Pass staged:true for the staging area. Optionally limit to a single validated file path.",
+      whenToUse: "To review what has changed in the working tree or staging area before a commit, or to analyse a specific file's modifications."
+    },
+    {
+      name: "gitLog",
+      usage: "gitLog({ limit: 10, oneline: false })",
+      description: "Returns recent commit history with hash, author, date, and message. Use oneline:true for a compact summary.",
+      whenToUse: "To understand the project's commit history, identify when a change was introduced, or generate a changelog summary."
+    },
+    {
+      name: "gitStatus",
+      usage: "gitStatus({})",
+      description: "Shows the working tree status grouped into staged changes, unstaged changes, and untracked files.",
+      whenToUse: "To get a quick overview of the current repository state before reviewing diffs or logs."
     }
   ];
 

package/src/engine/tools/webFetch.js

@@ -1,6 +1,7 @@
 import { lookup } from 'node:dns/promises';
 import { URL } from 'node:url';
 import ipaddr from 'ipaddr.js';
+import { parse } from 'node-html-parser';
 
 const MAX_CHARS = 15000;
 const TIMEOUT_MS = 10000;
@@ -117,16 +118,12 @@ export default async function webFetch({ url }) {
 
       // 5. HTML Stripping (Aggressive for context awareness)
       if (contentType.includes('text/html')) {
-        text = text
-          .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
-          .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
-          .replace(/<nav\b[^<]*(?:(?!<\/nav>)<[^<]*)*<\/nav>/gi, '')
-          .replace(/<header\b[^<]*(?:(?!<\/header>)<[^<]*)*<\/header>/gi, '')
-          .replace(/<footer\b[^<]*(?:(?!<\/footer>)<[^<]*)*<\/footer>/gi, '')
-          .replace(/<aside\b[^<]*(?:(?!<\/aside>)<[^<]*)*<\/aside>/gi, '')
-          .replace(/<[^>]+>/g, ' ')
-          .replace(/\s+/g, ' ')
-          .trim();
+        const root = parse(text);
+        root.querySelectorAll('script, style, nav, header, footer, aside').forEach(el => el.remove());
+        text = root.textContent;
+        text = text.replace(/<!DOCTYPE\b[^>]*>/gi, '');
+        text = text.replace(/<\?xml\b[^>]*>/gi, '');
+        text = text.replace(/\s+/g, ' ').trim();
       } else if (contentType.includes('application/json')) {
         try {
           text = JSON.stringify(JSON.parse(text), null, 2);

package/src/engine/tools/webSearch.js

@@ -1,3 +1,5 @@
+import { parse } from 'node-html-parser';
+
 const TIMEOUT_MS = 10000;
 const MAX_RESULTS_HARD_LIMIT = 20;
 
@@ -38,23 +40,20 @@ export default async function webSearch({ query, limit = 5 }) {
     const html = await response.text();
     const results = [];
     
-    // Split HTML into result blocks. 
-    // The slice(1) skips the header block before the first result.
-    const blocks = html.split('class="links_main links_deep result__body"').slice(1);
+    const root = parse(html);
+    const resultNodes = root.querySelectorAll('.result__body');
     
-    for (const block of blocks) {
+    for (const node of resultNodes) {
       if (results.length >= maxLimit) break;
       
-      const titleMatch = block.match(/<h2 class="result__title">[\s\S]*?<a[^>]*>([\s\S]*?)<\/a>/i);
-      const snippetMatch = block.match(/<a class="result__snippet[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+      const titleEl = node.querySelector('.result__title a');
+      const snippetEl = node.querySelector('.result__snippet');
       
-      if (titleMatch && snippetMatch) {
-        // Strip nested HTML tags (like <b> tags for highlighted keywords)
-        const title = titleMatch[1].replace(/<[^>]+>/g, '').trim();
-        const snippet = snippetMatch[2].replace(/<[^>]+>/g, '').trim();
+      if (titleEl && snippetEl) {
+        const title = titleEl.textContent.replace(/\s+/g, ' ').trim();
+        const snippet = snippetEl.textContent.replace(/\s+/g, ' ').trim();
         
-        // Clean DuckDuckGo's tracking wrapper from the URL
-        let url = snippetMatch[1];
+        let url = titleEl.getAttribute('href') || '';
         if (url.startsWith('//duckduckgo.com/l/?uddg=')) {
           url = decodeURIComponent(url.split('uddg=')[1].split('&')[0]);
         }