nou-cli 0.2.1 → 0.4.0

package/plugins/fetch-url.mjs

@@ -0,0 +1,82 @@
+// Starter plugin: lets the model read a web page (docs, an issue, a changelog) as plain text.
+const MAX_CHARS = 20_000;
+const TIMEOUT_MS = 15_000;
+
+const ENTITIES = { nbsp: " ", lt: "<", gt: ">", quot: "\"", "#39": "'", amp: "&" };
+
+/** Elements whose contents aren't page text. */
+const SKIPPED = new Set(["script", "style", "noscript", "svg"]);
+/** Tags that end a line of text. */
+const BREAKS = new Set(["br", "/p", "/div", "/li", "/tr", "/h1", "/h2", "/h3", "/h4", "/h5", "/h6"]);
+
+/**
+ * Keeps the text between tags. Every "<" starts a tag (page text writes a literal one as &lt;), which
+ * runs to the next ">"; skipped elements lose their contents too. Nothing tag-like can survive.
+ */
+function stripTags(html) {
+  const lower = html.toLowerCase();
+  let out = "";
+  let i = 0;
+  while (i < html.length) {
+    const open = lower.indexOf("<", i);
+    if (open < 0) return out + html.slice(i);
+    out += html.slice(i, open);
+    const end = lower.indexOf(">", open);
+    if (end < 0) return out; // a tag that never closes: the rest is inside it
+    // "p" for <p class=x>, "/p" for </p>, "br" for <br/>.
+    const inner = lower.slice(open + 1, end);
+    const closing = inner.startsWith("/");
+    const name = `${closing ? "/" : ""}${inner.slice(closing ? 1 : 0).split(/[\s/]/)[0]}`;
+    if (BREAKS.has(name)) out += "\n";
+    i = end + 1;
+    if (SKIPPED.has(name)) {
+      const close = lower.indexOf(`</${name}`, i);
+      if (close < 0) return out; // never closed: the rest is its contents
+      const closeEnd = lower.indexOf(">", close);
+      i = closeEnd < 0 ? html.length : closeEnd + 1;
+    }
+  }
+  return out;
+}
+
+/** Rough HTML to text: drops scripts, styles and tags, keeps the words. */
+export function htmlToText(html) {
+  // Entities after the tags, in one pass, so "&amp;lt;" becomes "&lt;", not "<".
+  return stripTags(html)
+    .replace(/&(nbsp|lt|gt|quot|#39|amp);/g, (_, name) => ENTITIES[name])
+    .replace(/[ \t]+/g, " ")
+    .replace(/\n\s*\n+/g, "\n\n")
+    .trim();
+}
+
+async function fetchText(url) {
+  if (!/^https?:\/\//i.test(url)) throw new Error("only http(s) URLs");
+  const response = await fetch(url, { signal: AbortSignal.timeout(TIMEOUT_MS), headers: { "user-agent": "nou-fetch-url" } });
+  const type = response.headers.get("content-type") ?? "";
+  const body = await response.text();
+  const text = type.includes("html") ? htmlToText(body) : body;
+  const cut = text.length > MAX_CHARS ? `${text.slice(0, MAX_CHARS)}\n[... ${text.length - MAX_CHARS} more chars cut]` : text;
+  return `${response.status} ${response.statusText} · ${url}\n\n${cut}`;
+}
+
+export default {
+  name: "Fetch URL",
+  version: "0.1.0",
+  description: "Adds a fetch_url tool so the model can read docs and web pages (asks first).",
+
+  tools: [
+    {
+      // Not read-only: it reaches the network, so you approve each URL.
+      definition: {
+        name: "fetch_url",
+        description: "Fetch a web page or file over http(s) and return it as text",
+        parameters: {
+          type: "object",
+          properties: { url: { type: "string", description: "The http(s) URL" } },
+          required: ["url"],
+        },
+      },
+      run: (args) => fetchText(String(args.url)),
+    },
+  ],
+};

package/plugins/project-rules.mjs

@@ -0,0 +1,43 @@
+// Starter plugin: gives the model the instructions you already wrote for other coding agents
+// (AGENTS.md, CLAUDE.md, Cursor and Copilot rules), so you don't have to repeat them in NOU.md.
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import process from "process";
+
+const FILES = ["AGENTS.md", "CLAUDE.md", "GEMINI.md", ".cursorrules", ".github/copilot-instructions.md"];
+const MAX_CHARS = 8_000;
+
+function readRules(cwd) {
+  return FILES.filter((file) => existsSync(path.join(cwd, file)))
+    .map((file) => {
+      const text = readFileSync(path.join(cwd, file), "utf-8").trim();
+      return { file, text: text.length > MAX_CHARS ? `${text.slice(0, MAX_CHARS)}\n[... cut]` : text };
+    })
+    .filter((rule) => rule.text);
+}
+
+export default {
+  name: "Project rules",
+  version: "0.1.0",
+  description: "Reads AGENTS.md, CLAUDE.md, .cursorrules and Copilot instructions into the system prompt. /rules lists them.",
+
+  // A getter, so edits to those files are picked up whenever the prompt is rebuilt.
+  get systemPrompt() {
+    const rules = readRules(process.cwd());
+    if (!rules.length) return undefined;
+    return `Follow the project's own instructions:\n${rules.map((r) => `--- ${r.file} ---\n${r.text}`).join("\n\n")}`;
+  },
+
+  commands: [
+    {
+      name: "rules",
+      description: "Show which instruction files are in use",
+      run(args, ctx) {
+        const rules = readRules(ctx.cwd);
+        return rules.length
+          ? `Using: ${rules.map((r) => `${r.file} (${r.text.length} chars)`).join(", ")}`
+          : `None found. Looked for ${FILES.join(", ")}.`;
+      },
+    },
+  ],
+};

package/plugins/run-tests.mjs

@@ -0,0 +1,89 @@
+// Starter plugin: lets the model (and you, with /test) run the project's tests.
+// It's yours to edit: set TEST_COMMAND if the guess below picks the wrong command.
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import process from "process";
+
+/** e.g. "npm run test:unit". Leave null to guess from the project files. */
+const TEST_COMMAND = null;
+const TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_OUTPUT = 12_000;
+
+function guessCommand(cwd) {
+  const has = (file) => existsSync(path.join(cwd, file));
+  if (has("package.json")) {
+    const test = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf-8")).scripts?.test;
+    if (test && !test.includes("no test specified")) {
+      if (has("pnpm-lock.yaml")) return "pnpm test";
+      if (has("yarn.lock")) return "yarn test";
+      if (has("bun.lock") || has("bun.lockb")) return "bun test";
+      return "npm test";
+    }
+  }
+  if (has("Cargo.toml")) return "cargo test";
+  if (has("go.mod")) return "go test ./...";
+  if (has("pyproject.toml") || has("pytest.ini") || has("setup.py") || has("tox.ini")) return "python -m pytest -q";
+  if (has("Makefile") && /^test:/m.test(readFileSync(path.join(cwd, "Makefile"), "utf-8"))) return "make test";
+  return null;
+}
+
+/** Runs the tests; extra arguments (a file, a filter) go after the command. */
+function runTests(cwd, extra) {
+  const base = TEST_COMMAND ?? guessCommand(cwd);
+  if (!base) return Promise.resolve({ command: null, code: null, output: "Couldn't tell how to run this project's tests. Set TEST_COMMAND in the run-tests plugin." });
+  const separator = extra && /^(npm|pnpm) /.test(base) ? " --" : "";
+  const command = extra ? `${base}${separator} ${extra}` : base;
+  return new Promise((resolve) => {
+    let output = "";
+    const child = spawn(command, { cwd, shell: true, env: { ...process.env, CI: "1", FORCE_COLOR: "0" } });
+    const timer = setTimeout(() => child.kill(), TIMEOUT_MS);
+    child.stdout.on("data", (d) => (output += d));
+    child.stderr.on("data", (d) => (output += d));
+    child.on("error", (error) => (output += `\n${error.message}`));
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      // The end of a test run (failures, summary) matters most.
+      const text = output.length > MAX_OUTPUT ? `[... ${output.length - MAX_OUTPUT} chars cut]\n${output.slice(-MAX_OUTPUT)}` : output;
+      resolve({ command, code, output: text.trim() });
+    });
+  });
+}
+
+export default {
+  name: "Run tests",
+  version: "0.1.0",
+  description: "Adds a run_tests tool and /test. Works out npm/pnpm/yarn/bun, cargo, go, pytest or make.",
+  systemPrompt: "After changing code, use run_tests to check your work, and fix any failures you caused.",
+
+  tools: [
+    {
+      // Running tests runs project code, so you approve each run.
+      definition: {
+        name: "run_tests",
+        description: "Run the project's test suite (or part of it) and return the output",
+        parameters: {
+          type: "object",
+          properties: { args: { type: "string", description: "Optional extra arguments, e.g. a test file or name filter" } },
+        },
+      },
+      async run(args, ctx) {
+        const { command, code, output } = await runTests(ctx.cwd, args.args?.trim());
+        return command ? `$ ${command}\nexit code ${code}\n${output}` : output;
+      },
+    },
+  ],
+
+  commands: [
+    {
+      name: "test",
+      description: "Run the tests: /test [args]",
+      async run(args, ctx) {
+        const { command, code, output } = await runTests(ctx.cwd, args.trim());
+        if (!command) return output;
+        const tail = output.split("\n").slice(-25).join("\n");
+        return `${code === 0 ? "✓ passed" : `✗ failed (exit ${code})`}: ${command}\n${tail}`;
+      },
+    },
+  ],
+};

package/plugins/todos.mjs

@@ -0,0 +1,81 @@
+// Starter plugin: finds TODO / FIXME / HACK comments, for you (/todos) and the model (find_todos).
+import { execFileSync } from "child_process";
+import { readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+
+const MARKERS = /\b(TODO|FIXME|HACK|XXX)\b:?\s*(.*)/;
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "out", "target", "vendor", ".venv", "__pycache__", "coverage"]);
+const MAX_FILE_BYTES = 1_000_000;
+const MAX_RESULTS = 200;
+
+/** Files git knows about (so .gitignore is respected), or a plain walk outside a repo. */
+function listFiles(cwd, under) {
+  try {
+    const out = execFileSync("git", ["ls-files", "-co", "--exclude-standard", "--", under || "."], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    return out.split("\n").filter(Boolean);
+  } catch {
+    const files = [];
+    const walk = (dir) => {
+      for (const name of readdirSync(path.join(cwd, dir))) {
+        if (SKIP_DIRS.has(name) || files.length > 20_000) continue;
+        const rel = path.join(dir, name);
+        if (statSync(path.join(cwd, rel)).isDirectory()) walk(rel);
+        else files.push(rel);
+      }
+    };
+    walk(under || ".");
+    return files;
+  }
+}
+
+function findTodos(cwd, under) {
+  const found = [];
+  for (const file of listFiles(cwd, under)) {
+    if (found.length >= MAX_RESULTS) break;
+    try {
+      const full = path.join(cwd, file);
+      if (statSync(full).size > MAX_FILE_BYTES) continue;
+      const text = readFileSync(full, "utf-8");
+      if (text.includes("\0")) continue; // binary
+      text.split("\n").forEach((line, i) => {
+        const match = MARKERS.exec(line);
+        if (match && found.length < MAX_RESULTS) found.push(`${file.replaceAll("\\", "/")}:${i + 1}  ${match[1]} ${match[2].trim()}`);
+      });
+    } catch {
+      // unreadable or deleted: skip
+    }
+  }
+  return found;
+}
+
+const report = (found) =>
+  found.length ? `${found.length}${found.length === MAX_RESULTS ? "+" : ""} found:\n${found.join("\n")}` : "No TODO/FIXME/HACK comments found.";
+
+export default {
+  name: "TODOs",
+  version: "0.1.0",
+  description: "Lists TODO / FIXME / HACK comments. Adds a find_todos tool and /todos.",
+
+  tools: [
+    {
+      readOnly: true,
+      definition: {
+        name: "find_todos",
+        description: "List TODO, FIXME, HACK and XXX comments in the project (file:line and the note)",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string", description: "Optional folder to search, relative to the project" } },
+        },
+      },
+      run: (args, ctx) => report(findTodos(ctx.cwd, args.path)),
+    },
+  ],
+
+  commands: [
+    {
+      name: "todos",
+      description: "List TODO/FIXME comments: /todos [folder]",
+      run: (args, ctx) => report(findTodos(ctx.cwd, args.trim())),
+    },
+  ],
+};