@hncode/hncode 0.1.0

package/src/tools/todo.js

@@ -0,0 +1,33 @@
+// TodoList tool — mirrors the hncode TodoList tool schema & behavior.
+// Replaces the agent's todo list with the full list provided.
+
+export const spec = {
+  name: 'TodoList',
+  description: 'Track multi-step work. Pass the COMPLETE list; it replaces the current one. Items: title + status (pending | in_progress | done).',
+  parameters: {
+    type: 'object',
+    properties: {
+      todos: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Short, actionable task title.' },
+            status: { type: 'string', enum: ['pending', 'in_progress', 'done'], description: 'Current status.' },
+          },
+          required: ['title', 'status'],
+        },
+        description: 'The full todo list.',
+      },
+    },
+    required: ['todos'],
+  },
+  async execute(args, ctx) {
+    ctx.todoState = args.todos.map((t) => ({ title: String(t.title), status: t.status || 'pending' }));
+    return render(ctx.todoState);
+  },
+};
+
+export function render(list) {
+  return 'Todo list:\n' + (list || []).map((t) => `- [${t.status}] ${t.title}`).join('\n');
+}

package/src/tools/utils.js

@@ -0,0 +1,71 @@
+// Shared helpers for the hncode toolbelt.
+
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+
+export const MAX_OUTPUT_BYTES = 128 * 1024; // cap tool results to avoid token blowup
+
+export function truncateBuf(buf) {
+  if (Buffer.isBuffer(buf)) {
+    if (buf.length <= MAX_OUTPUT_BYTES) return buf.toString('utf8');
+    return buf.subarray(0, MAX_OUTPUT_BYTES).toString('utf8') + `\n...[truncated ${buf.length - MAX_OUTPUT_BYTES} bytes]`;
+  }
+  const s = String(buf);
+  if (s.length <= MAX_OUTPUT_BYTES) return s;
+  return s.slice(0, MAX_OUTPUT_BYTES) + `\n...[truncated ${s.length - MAX_OUTPUT_BYTES} chars]`;
+}
+
+// Expand ~ and map Git-Bash /c/x -> C:\x style paths, then resolve against cwd.
+export function normalizeInput(p) {
+  let s = String(p);
+  if (s.startsWith('~')) s = path.join(os.homedir(), s.slice(1));
+  const m = s.match(/^\/([a-zA-Z])\/(.*)$/);
+  if (m) return path.join(`${m[1].toUpperCase()}:\\`, ...m[2].split('/'));
+  return s;
+}
+
+export function resolvePath(input, ctx) {
+  const raw = normalizeInput(input);
+  let p = path.resolve(ctx.cwd || ctx.workspace, raw);
+  try { p = fs.realpathSync(p); } catch {} // resolve symlinks if present
+  const ws = path.resolve(ctx.cwd || ctx.workspace);
+  if (!ctx.allowExternal) {
+    let rel = path.relative(ws, p);
+    if (rel === '') return p;
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+      throw new Error(`Path outside workspace: ${input}. Run hncode from that directory or set HNCODE_ALLOW_EXTERNAL=1.`);
+    }
+  }
+  return p;
+}
+
+export function ensureDir(p) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+}
+
+// Read a file fully, returning its string. Throws if not a file.
+export function readFileBytes(p) {
+  const st = fs.statSync(p);
+  if (!st.isFile() && !st.isFIFO()) throw new Error(`Not a file: ${p}`);
+  return fs.readFileSync(p);
+}
+
+// Visible width ignoring ANSI escapes (approx).
+export function visibleWidth(s) {
+  return (s || '').replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').length;
+}
+
+export function isProbablyTextFile(buf) {
+  // Treat as text if mostly printable ASCII/UTF-8 and few NULs.
+  if (buf.length === 0) return true;
+  let nulls = 0;
+  for (let i = 0; i < Math.min(buf.length, 8192); i++) if (buf[i] === 0) nulls++;
+  if (nulls > 0) return false;
+  let bad = 0;
+  for (let i = 0; i < Math.min(buf.length, 8192); i++) {
+    const b = buf[i];
+    if (b < 9 || (b > 13 && b < 32) || b > 254) bad++;
+  }
+  return bad / Math.min(buf.length, 8192) < 0.10;
+}

package/src/tools/web-search.js

@@ -0,0 +1,75 @@
+// WebSearch tool — search the web via Bing's HTML endpoint (no API key needed).
+
+import { htmlToText } from './fetch-url.js';
+
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36';
+
+function decodeEntities(s) {
+  return String(s || '')
+    .replace(/ /gi, ' ')
+    .replace(/&/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;|&apos;/gi, "'")
+    .replace(/&ensp;/gi, ' ')
+    .replace(/&emsp;/gi, ' ')
+    .replace(/&middot;/gi, '·')
+    .replace(/&hellip;/gi, '…')
+    .replace(/&#(\d+);/g, (_, d) => String.fromCharCode(Number(d)));
+}
+
+// Parse Bing's HTML into { title, url, snippet } results.
+export function parseBingResults(html, limit = 8) {
+  const out = [];
+  const blocks = String(html).match(/<li class="b_algo"[\s\S]*?<\/li>/g) || [];
+  for (const block of blocks) {
+    const href = (block.match(/<a[^>]+href="(https?:\/\/[^"]+)"/) || [])[1];
+    if (!href) continue;
+    const titleHtml = (block.match(/<h2[^>]*>[\s\S]*?<a[^>]*>([\s\S]*?)<\/a>/) || [])[1] || '';
+    const title = decodeEntities(titleHtml.replace(/<[^>]+>/g, '')).trim();
+    // Snippet lives in <p> or a caption div; fall back to stripped block text.
+    let snippet = (block.match(/<p[^>]*>([\s\S]*?)<\/p>/) || [])[1]
+      || (block.match(/class="b_caption"[^>]*>[\s\S]*?<p[^>]*>([\s\S]*?)<\/p>/) || [])[1]
+      || '';
+    snippet = decodeEntities(snippet.replace(/<[^>]+>/g, '')).replace(/\s+/g, ' ').trim();
+    if (!snippet) snippet = htmlToText(block).replace(/\s+/g, ' ').slice(0, 240);
+    out.push({ title: title || href, url: href, snippet });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+export const spec = {
+  name: 'WebSearch',
+  description: 'Search the web. Results are title/URL/snippet; snippets are summaries, so fetch a promising URL with FetchURL. Cite sources.',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query.' },
+    },
+    required: ['query'],
+  },
+  async execute(args, ctx) {
+    const query = String(args.query || '').trim();
+    if (!query) return 'Error: query must not be empty.';
+    const signal = (ctx && ctx.signal) || undefined;
+    const url = 'https://www.bing.com/search?q=' + encodeURIComponent(query) + '&setlang=en';
+    try {
+      const res = await fetch(url, {
+        headers: { 'User-Agent': UA, 'Accept-Language': 'en-US,en;q=0.9' },
+        signal,
+      });
+      if (!res.ok) return `Error: search failed (${res.status} ${res.statusText}).`;
+      const html = await res.text();
+      const results = parseBingResults(html, 8);
+      if (!results.length) return `No search results found for: ${query}`;
+      return results
+        .map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`)
+        .join('\n\n');
+    } catch (e) {
+      const msg = e && e.name === 'AbortError' ? 'interrupted' : (e.message || String(e));
+      return `Error searching "${query}": ${msg}`;
+    }
+  },
+};

package/src/tools/write.js

@@ -0,0 +1,29 @@
+// Write tool — mirrors the hncode Write tool schema & behavior.
+
+import fs from 'node:fs';
+import { resolvePath, ensureDir, truncateBuf } from './utils.js';
+
+export const spec = {
+  name: 'Write',
+  description: 'Create or overwrite a file (prefer Edit for existing files). mode: overwrite (default) | append.',
+  parameters: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Path to the file.' },
+      content: { type: 'string', description: 'Content to write.' },
+      mode: { type: 'string', enum: ['overwrite', 'append'], default: 'overwrite', description: 'Overwrite or append.' },
+    },
+    required: ['path', 'content'],
+  },
+  async execute(args, ctx) {
+    let p;
+    try { p = resolvePath(args.path, ctx); } catch (e) { return e.message; }
+    try {
+      ensureDir(p);
+      const flag = args.mode === 'append' ? 'a' : 'w';
+      fs.writeFileSync(p, args.content, { flag });
+    } catch (e) { return `Error writing ${args.path}: ${e.message}`; }
+    const size = fs.statSync(p).size;
+    return `File written: ${args.path} (${size} bytes)`;
+  },
+};