@marcfargas/skills 0.2.0 → 0.3.0

package/search/web-search/search.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "child_process";
+import { readFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+
+const args = process.argv.slice(2);
+
+// Parse --content flag
+const contentIndex = args.indexOf("--content");
+const fetchContent = contentIndex !== -1;
+if (fetchContent) args.splice(contentIndex, 1);
+
+// Parse --news flag
+const newsIndex = args.indexOf("--news");
+const isNews = newsIndex !== -1;
+if (isNews) args.splice(newsIndex, 1);
+
+// Parse -n <num>
+let numResults = 5;
+const nIndex = args.indexOf("-n");
+if (nIndex !== -1 && args[nIndex + 1]) {
+	numResults = parseInt(args[nIndex + 1], 10);
+	args.splice(nIndex, 2);
+}
+
+// Parse -r <region>
+let region = null;
+const rIndex = args.indexOf("-r");
+if (rIndex !== -1 && args[rIndex + 1]) {
+	region = args[rIndex + 1];
+	args.splice(rIndex, 2);
+}
+
+// Parse -t <timelimit>
+let timelimit = null;
+const tIndex = args.indexOf("-t");
+if (tIndex !== -1 && args[tIndex + 1]) {
+	timelimit = args[tIndex + 1];
+	args.splice(tIndex, 2);
+}
+
+// Parse -b <backend>
+let backend = null;
+const bIndex = args.indexOf("-b");
+if (bIndex !== -1 && args[bIndex + 1]) {
+	backend = args[bIndex + 1];
+	args.splice(bIndex, 2);
+}
+
+const query = args.join(" ");
+
+if (!query) {
+	console.log("Usage: search.js [--news] <query> [-n <num>] [--content] [-r <region>] [-t <timelimit>] [-b <backend>]");
+	console.log("\nOptions:");
+	console.log("  --news                News search instead of web search");
+	console.log("  -n <num>              Number of results (default: 5)");
+	console.log("  --content             Fetch readable content as markdown");
+	console.log("  -r <region>           Region: us-en, es-es, de-de, fr-fr, etc.");
+	console.log("  -t <timelimit>        Time filter: d (day), w (week), m (month), y (year)");
+	console.log("  -b <backend>          Backend: auto, all, bing, brave, duckduckgo, google, etc.");
+	console.log("\nExamples:");
+	console.log('  search.js "javascript async await"');
+	console.log('  search.js "rust programming" -n 10');
+	console.log('  search.js "climate change" --content');
+	console.log('  search.js --news "AI agents" -t w');
+	process.exit(1);
+}
+
+function htmlToMarkdown(html) {
+	const turndown = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+	turndown.use(gfm);
+	turndown.addRule("removeEmptyLinks", {
+		filter: (node) => node.nodeName === "A" && !node.textContent?.trim(),
+		replacement: () => "",
+	});
+	return turndown
+		.turndown(html)
+		.replace(/\[\\?\[\s*\\?\]\]\([^)]*\)/g, "")
+		.replace(/ +/g, " ")
+		.replace(/\s+,/g, ",")
+		.replace(/\s+\./g, ".")
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+}
+
+async function fetchPageContent(url) {
+	try {
+		const response = await fetch(url, {
+			headers: {
+				"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+				"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+			},
+			signal: AbortSignal.timeout(10000),
+		});
+
+		if (!response.ok) {
+			return `(HTTP ${response.status})`;
+		}
+
+		const html = await response.text();
+		const dom = new JSDOM(html, { url });
+		const reader = new Readability(dom.window.document);
+		const article = reader.parse();
+
+		if (article && article.content) {
+			return htmlToMarkdown(article.content).substring(0, 5000);
+		}
+
+		// Fallback: try to get main content
+		const fallbackDoc = new JSDOM(html, { url });
+		const body = fallbackDoc.window.document;
+		body.querySelectorAll("script, style, noscript, nav, header, footer, aside").forEach((el) => el.remove());
+		const main = body.querySelector("main, article, [role='main'], .content, #content") || body.body;
+		const text = main?.textContent || "";
+
+		if (text.trim().length > 100) {
+			return text.trim().substring(0, 5000);
+		}
+
+		return "(Could not extract content)";
+	} catch (e) {
+		return `(Error: ${e.message})`;
+	}
+}
+
+function runDdgs(query, numResults, isNews, region, timelimit, backend) {
+	const tmpFile = join(tmpdir(), `ddgs-${randomBytes(6).toString("hex")}.json`);
+	const subcommand = isNews ? "news" : "text";
+
+	const ddgsArgs = [subcommand, "-q", query, "-m", String(numResults), "-o", tmpFile];
+
+	if (region) {
+		ddgsArgs.push("-r", region);
+	}
+	if (timelimit) {
+		ddgsArgs.push("-t", timelimit);
+	}
+	if (backend) {
+		ddgsArgs.push("-b", backend);
+	}
+
+	try {
+		execFileSync("ddgs", ddgsArgs, {
+			stdio: ["pipe", "pipe", "pipe"],
+			timeout: 30000,
+		});
+	} catch (e) {
+		// ddgs may write output to file even if it exits with error
+		// (e.g. "Aborted!" after printing results)
+	}
+
+	try {
+		const raw = readFileSync(tmpFile, "utf-8");
+		unlinkSync(tmpFile);
+		return JSON.parse(raw);
+	} catch {
+		try {
+			unlinkSync(tmpFile);
+		} catch {}
+		throw new Error("ddgs produced no results. Is ddgs installed? Run: uv tool install ddgs");
+	}
+}
+
+// Main
+try {
+	const rawResults = runDdgs(query, numResults, isNews, region, timelimit, backend);
+
+	if (!rawResults || rawResults.length === 0) {
+		console.error("No results found.");
+		process.exit(0);
+	}
+
+	// Normalize results to a common shape
+	const results = rawResults.map((r) => ({
+		title: r.title || "",
+		link: r.href || r.url || "",
+		snippet: r.body || "",
+		date: r.date || "",
+		source: r.source || "",
+	}));
+
+	if (fetchContent) {
+		for (const result of results) {
+			result.content = await fetchPageContent(result.link);
+		}
+	}
+
+	for (let i = 0; i < results.length; i++) {
+		const r = results[i];
+		console.log(`--- Result ${i + 1} ---`);
+		console.log(`Title: ${r.title}`);
+		console.log(`Link: ${r.link}`);
+		if (r.date) {
+			console.log(`Date: ${r.date}`);
+		}
+		if (r.source) {
+			console.log(`Source: ${r.source}`);
+		}
+		console.log(`Snippet: ${r.snippet}`);
+		if (r.content) {
+			console.log(`Content:\n${r.content}`);
+		}
+		console.log("");
+	}
+} catch (e) {
+	console.error(`Error: ${e.message}`);
+	process.exit(1);
+}

package/terminal/vhs/SKILL.md

@@ -106,13 +106,23 @@ Require git                        # Fail if git not in PATH
 Require node
 ```
 
+## Windows: Use `Set Shell "cmd"`
+
+VHS's default `bash` resolves to WSL bash on Windows — a separate environment with no access to Windows-installed tools (node, scoop packages, etc.). **Always use `cmd`** on Windows:
+
+```tape
+Set Shell "cmd"
+```
+
+This gives VHS the full Windows PATH so all installed CLIs work.
+
 ## Recommended Defaults
 
 For README demos and documentation:
 
 ```tape
 Output demo.gif
-Set Shell "bash"
+Set Shell "cmd"                    # Windows — use "bash" on Linux/macOS
 Set FontSize 14
 Set Width 1100
 Set Height 600
@@ -211,6 +221,82 @@ vhs record > my-session.tape
 vhs my-session.tape
 ```
 
+### Recording TUI apps with holdpty
+
+Use [holdpty](https://github.com/marcfargas/holdpty) to record full-color TUI applications — apps that need a real PTY for colors, take time to start, or are already running. holdpty provides the PTY, VHS captures the output.
+
+**Why this matters:**
+- TUI apps (pi, htop, k9s, lazygit) need a real PTY for colors and layout
+- Slow-starting apps (AI agents, servers) can be ready before recording begins
+- Already-running processes can be recorded on demand for monitoring/sharing
+
+**The pattern:**
+
+```bash
+# Step 1: Launch the app in holdpty (or it's already running)
+holdpty launch --bg --name demo -- my-tui-app
+
+# Step 2: Wait for it to be ready (or it already is)
+sleep 5
+
+# Step 3: Record with VHS
+vhs record-demo.tape
+
+# Step 4: Clean up (or leave it running)
+holdpty stop demo
+```
+
+**Tape file — attach to a running session:**
+
+```tape
+Output demo.gif
+Output demo.mp4
+Set Shell "cmd"
+Set FontSize 14
+Set Width 1200
+Set Height 700
+Set Theme "Dracula"
+Set Padding 15
+Set WindowBar "Colorful"
+Set BorderRadius 8
+
+# Attach to the running holdpty session
+Type "holdpty attach demo"
+Enter
+Sleep 2s
+
+# Interact with the app (VHS types, app responds with full TUI)
+Type "your input here"
+Enter
+Sleep 15s
+```
+
+**Tape file — view-only snapshot of a running process:**
+
+```tape
+Output snapshot.gif
+Set Shell "cmd"
+Set FontSize 14
+Set Width 1200
+Set Height 700
+Set Theme "Dracula"
+Set Padding 15
+
+# View is read-only — just captures current output
+Type "holdpty view demo"
+Enter
+Sleep 10s
+Ctrl+C
+```
+
+**Use cases:**
+- **README demos** — launch app, let it start, record the interesting part
+- **Monitoring snapshots** — capture what a running service looks like right now
+- **Bug reports** — record a live reproduction with full colors
+- **Agent recordings** — capture an AI agent working with its full TUI (thinking indicators, tool calls, colored output)
+
+> On Windows, use `node.exe <path/to/cli.js>` instead of CLI names when launching via holdpty — see the [holdpty skill](https://github.com/marcfargas/holdpty) for the `.cmd` wrapper gotcha.
+
 ## Themes
 
 Popular themes for demos:
@@ -241,8 +327,10 @@ List all: `vhs themes`
 
 ## Gotchas
 
+- **Windows: `Set Shell "bash"` uses WSL** — VHS resolves `bash` to WSL bash, not Git Bash. Use `Set Shell "cmd"` to get the full Windows PATH. Custom shell paths (`Set Shell "C:/path/to/bash.exe"`) are rejected.
 - **No shell expansion in Type** — `Type "echo $HOME"` types the literal string; variable expansion happens when bash executes it, not in the tape
 - **Quoting** — avoid nested quotes in Type. Use wrapper scripts for complex commands
 - **Windows paths** — use forward slashes in Type strings (`C:/dev/...` not `C:\dev\...`)
 - **Long recordings** — GIFs get huge fast. Keep demos under 30 seconds. Use `Set PlaybackSpeed 2.0` to compress
 - **Terminal size** — if output wraps weird, increase Width or reduce FontSize
+- **TUI apps without holdpty** — apps that need a real PTY for colors (pi, htop, lazygit) will render without colors if launched directly from VHS. Use the holdpty pattern above.