harnery 0.0.1 → 0.2.1

package/dist/commands/eml.js

@@ -0,0 +1,428 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { simpleParser } from "mailparser";
+export function registerEmlCommand(program, emit) {
+    program
+        .command("eml")
+        .description("Parse a Gmail .eml file into a clean chronological markdown thread")
+        .argument("<file>", "Path to the .eml file")
+        .option("-o, --output <path>", "Write output to a file instead of stdout")
+        .option("--format <type>", "Output format: markdown, json", "markdown")
+        .option("--headers", "Include full email headers per message")
+        .option("--attachments", "List attachment filenames and sizes")
+        .action(async (file, opts) => {
+        try {
+            await handleEml(file, opts, emit);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            emit.error({ code: "eml_error", message: msg });
+            process.exit(1);
+        }
+    });
+}
+async function handleEml(file, opts, emit) {
+    const raw = readFileSync(file);
+    const parsed = await simpleParser(raw);
+    const messages = extractThread(parsed);
+    if (messages.length === 0) {
+        emit.error({ code: "no_messages", message: "No messages found in the .eml file." });
+        process.exit(1);
+    }
+    if (opts.format === "json") {
+        const rows = messages.map((m, i) => ({
+            index: i + 1,
+            from: m.from,
+            date: m.date?.toISOString() ?? null,
+            body: m.body,
+        }));
+        if (opts.output) {
+            writeFileSync(opts.output, JSON.stringify(rows));
+            emit.file(opts.output, { messages: messages.length, format: "json" });
+        }
+        else {
+            emit.config({ format: "json" });
+            emit.rows(rows);
+        }
+        return;
+    }
+    const output = renderMarkdown(parsed, messages, opts);
+    if (opts.output) {
+        writeFileSync(opts.output, output);
+        emit.file(opts.output, { messages: messages.length, format: "markdown" });
+    }
+    else {
+        emit.text(output);
+    }
+}
+/**
+ * Extract individual messages from the parsed email.
+ * Strategy: use HTML body (Gmail quote structure) first, fall back to plain text.
+ */
+function extractThread(parsed) {
+    if (parsed.html && typeof parsed.html === "string") {
+        const messages = extractFromHtml(parsed.html, parsed);
+        if (messages.length > 0)
+            return messages;
+    }
+    // Fallback: plain text
+    if (parsed.text) {
+        return extractFromPlainText(parsed.text, parsed);
+    }
+    return [];
+}
+/**
+ * Parse Gmail's nested HTML quote structure.
+ *
+ * Gmail wraps each quoted reply in:
+ *   <div class="gmail_quote">
+ *     <div class="gmail_attr">On <date>, <name> <<email>> wrote:</div>
+ *     <blockquote class="gmail_quote">...nested older messages...</blockquote>
+ *   </div>
+ */
+function extractFromHtml(html, parsed) {
+    const messages = [];
+    // Work with the decoded HTML
+    const doc = html;
+    // Extract attribution lines and their positions to find message boundaries
+    // Pattern: <div ... class="gmail_attr">On ..., ... wrote:<br></div>
+    const attrPattern = /class=["']gmail_attr["'][^>]*>([\s\S]*?)<\/div>/gi;
+    const attrs = [];
+    let match = attrPattern.exec(doc);
+    while (match !== null) {
+        attrs.push({ text: stripHtml(match[1]), index: match.index });
+        match = attrPattern.exec(doc);
+    }
+    // The top-level message (newest) is before the first gmail_quote
+    const firstQuoteIdx = doc.search(/class=["']gmail_quote\s*(gmail_quote_container)?["']/i);
+    if (firstQuoteIdx > 0) {
+        // Extract the top-level body (everything before the first quote container)
+        const topBody = extractBodyBeforeQuote(doc, firstQuoteIdx);
+        if (topBody.trim()) {
+            messages.push({
+                from: formatAddress(parsed.from),
+                date: parsed.date ?? null,
+                body: topBody,
+            });
+        }
+    }
+    else {
+        // No quotes - single message
+        messages.push({
+            from: formatAddress(parsed.from),
+            date: parsed.date ?? null,
+            body: cleanBody(stripHtml(doc)),
+        });
+        return messages;
+    }
+    // Now extract each quoted message using attribution lines
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        const { name, date } = parseAttribution(attr.text);
+        // Find the blockquote that follows this attribution
+        const afterAttr = doc.indexOf("</div>", attr.index + 10);
+        if (afterAttr === -1)
+            continue;
+        // Find the blockquote content after the attribution div
+        const searchRegion = doc.slice(afterAttr, afterAttr + 500);
+        const bqStart = searchRegion.indexOf("<blockquote");
+        if (bqStart === -1)
+            continue;
+        const bqStartAbsolute = afterAttr + bqStart;
+        const bqContent = extractBlockquoteContent(doc, bqStartAbsolute);
+        // The body is everything in this blockquote BEFORE any nested gmail_quote
+        const nestedQuoteIdx = bqContent.search(/class=["']gmail_quote["']/i);
+        const bodyHtml = nestedQuoteIdx > 0 ? bqContent.slice(0, nestedQuoteIdx) : bqContent;
+        // Find the actual start of content (skip the opening blockquote tag)
+        const tagEnd = bodyHtml.indexOf(">");
+        const content = tagEnd > 0 ? bodyHtml.slice(tagEnd + 1) : bodyHtml;
+        const body = cleanBody(stripHtml(content));
+        if (body.trim()) {
+            messages.push({ from: name, date, body });
+        }
+    }
+    // Reverse: messages are newest-first in the .eml, we want oldest-first
+    messages.reverse();
+    return messages;
+}
+/**
+ * Extract content of a blockquote tag, handling nested blockquotes.
+ */
+function extractBlockquoteContent(html, startIdx) {
+    let depth = 0;
+    let i = startIdx;
+    const openTag = /<blockquote/gi;
+    const closeTag = /<\/blockquote>/gi;
+    // Find the end of the opening tag
+    const tagEnd = html.indexOf(">", startIdx);
+    if (tagEnd === -1)
+        return "";
+    i = tagEnd + 1;
+    depth = 1;
+    while (depth > 0 && i < html.length) {
+        openTag.lastIndex = i;
+        closeTag.lastIndex = i;
+        const nextOpen = openTag.exec(html);
+        const nextClose = closeTag.exec(html);
+        if (!nextClose)
+            break;
+        if (nextOpen && nextOpen.index < nextClose.index) {
+            depth++;
+            i = nextOpen.index + 12;
+        }
+        else {
+            depth--;
+            if (depth === 0) {
+                return html.slice(tagEnd + 1, nextClose.index);
+            }
+            i = nextClose.index + 13;
+        }
+    }
+    return html.slice(tagEnd + 1, Math.min(startIdx + 50000, html.length));
+}
+/**
+ * Get body content before the first gmail_quote div.
+ */
+function extractBodyBeforeQuote(html, quoteIdx) {
+    // Walk backwards from the quote to find the containing div
+    // The body is typically in the main content area before the quote
+    let bodyHtml = html.slice(0, quoteIdx);
+    // Remove the outermost container divs and get to the content
+    // Look for the last closing tag before the quote div's opening
+    const lastDivOpen = bodyHtml.lastIndexOf('<div class="gmail_quote');
+    if (lastDivOpen === -1) {
+        // Try the simpler approach: strip from after <body> or start of content
+        const bodyTag = bodyHtml.indexOf("<body");
+        if (bodyTag > 0) {
+            const bodyEnd = bodyHtml.indexOf(">", bodyTag);
+            bodyHtml = bodyHtml.slice(bodyEnd + 1);
+        }
+    }
+    else {
+        bodyHtml = bodyHtml.slice(0, lastDivOpen);
+    }
+    return cleanBody(stripHtml(bodyHtml));
+}
+/**
+ * Fallback: parse plain text thread using "> " quote markers and "On ... wrote:" patterns.
+ */
+function extractFromPlainText(text, parsed) {
+    const messages = [];
+    const wrotePattern = /^On\s+.+\s+wrote:\s*$/m;
+    const parts = text.split(wrotePattern);
+    if (parts.length <= 1) {
+        // No quoted thread found, single message
+        messages.push({
+            from: formatAddress(parsed.from),
+            date: parsed.date ?? null,
+            body: cleanBody(text),
+        });
+        return messages;
+    }
+    // First part is the newest message body
+    messages.push({
+        from: formatAddress(parsed.from),
+        date: parsed.date ?? null,
+        body: cleanBody(parts[0]),
+    });
+    // Find all "On ... wrote:" lines to get attributions
+    const attrMatches = [...text.matchAll(/^(On\s+.+\s+wrote:)\s*$/gm)];
+    for (let i = 0; i < attrMatches.length; i++) {
+        const attrText = attrMatches[i][1];
+        const { name, date } = parseAttribution(attrText);
+        // The body is the next part, with ">" prefixes stripped
+        if (i + 1 < parts.length) {
+            const quotedBody = parts[i + 1]
+                .split("\n")
+                .map((line) => line.replace(/^>+\s?/, ""))
+                .join("\n");
+            messages.push({ from: name, date, body: cleanBody(quotedBody) });
+        }
+    }
+    messages.reverse();
+    return messages;
+}
+/**
+ * Parse an attribution line like "On Fri, Apr 10, 2026 at 9:21 AM Tyler Prins <tyler@...> wrote:"
+ */
+function parseAttribution(text) {
+    const cleaned = text.replace(/\s+/g, " ").trim();
+    // Extract date: "On <date>, <name> ... wrote:"
+    // Pattern: On <day>, <month> <day>, <year> at <time> <AM/PM>
+    const dateMatch = cleaned.match(/On\s+\w+,\s+(\w+\s+\d{1,2},\s+\d{4})\s+at\s+(\d{1,2}:\d{2})\s*(?:\u202F|\s)*(AM|PM)?/i);
+    let date = null;
+    if (dateMatch) {
+        const dateStr = `${dateMatch[1]} ${dateMatch[2]} ${dateMatch[3] ?? ""}`.trim();
+        const parsed = new Date(dateStr);
+        if (!Number.isNaN(parsed.getTime())) {
+            date = parsed;
+        }
+    }
+    // Extract name: everything after the time and before "wrote:" or before < email >
+    const nameMatch = cleaned.match(/(?:AM|PM)\s+(.+?)(?:\s*<[^>]+>)?\s+wrote:/i);
+    let name = "Unknown";
+    if (nameMatch) {
+        name = nameMatch[1].replace(/<[^>]+>/g, "").trim();
+    }
+    else {
+        // Try simpler pattern without AM/PM
+        const simpleMatch = cleaned.match(/at\s+[\d:]+\s+(.+?)(?:\s*<[^>]+>)?\s+wrote:/i);
+        if (simpleMatch) {
+            name = simpleMatch[1].replace(/<[^>]+>/g, "").trim();
+        }
+    }
+    return { name, date };
+}
+/**
+ * Strip HTML tags, decode entities, and normalize whitespace.
+ */
+function stripHtml(html) {
+    let text = html;
+    // Replace <br>, <br/>, <br /> with newlines
+    text = text.replace(/<br\s*\/?>/gi, "\n");
+    // Replace block-level elements with newlines
+    text = text.replace(/<\/(p|div|tr|li|h[1-6])>/gi, "\n");
+    text = text.replace(/<(p|div|tr|li|h[1-6])\b[^>]*>/gi, "\n");
+    // Replace <td> with tab
+    text = text.replace(/<\/td>/gi, "\t");
+    // Remove all remaining HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Decode HTML entities
+    text = decodeEntities(text);
+    // Normalize whitespace (but preserve newlines)
+    text = text
+        .split("\n")
+        .map((line) => line.replace(/[ \t]+/g, " ").trim())
+        .join("\n");
+    return text;
+}
+/**
+ * Decode common HTML entities.
+ */
+function decodeEntities(text) {
+    const entities = {
+        "&amp;": "&",
+        "&lt;": "<",
+        "&gt;": ">",
+        "&quot;": '"',
+        "&#39;": "'",
+        "&apos;": "'",
+        "&nbsp;": " ",
+        "&#160;": " ",
+        "&ndash;": "-",
+        "&mdash;": "-",
+        "&laquo;": "<<",
+        "&raquo;": ">>",
+        "&bull;": "*",
+        "&hellip;": "...",
+        "&copy;": "(c)",
+        "&reg;": "(R)",
+        "&trade;": "(TM)",
+    };
+    let result = text;
+    for (const [entity, char] of Object.entries(entities)) {
+        result = result.replaceAll(entity, char);
+    }
+    // Decode numeric entities (&#NNN; and &#xHHH;)
+    result = result.replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number.parseInt(code, 10)));
+    result = result.replace(/&#x([0-9a-fA-F]+);/g, (_, code) => String.fromCharCode(Number.parseInt(code, 16)));
+    return result;
+}
+/**
+ * Clean up message body text.
+ */
+function cleanBody(text) {
+    let body = text;
+    // Remove common email signatures
+    const sigPatterns = [
+        /^--\s*$/m, // standard sig delimiter
+        /^Sent from my (iPhone|iPad|Galaxy|Android|Samsung)/m,
+        /^Get Outlook for/m,
+    ];
+    for (const pattern of sigPatterns) {
+        const match = body.match(pattern);
+        if (match?.index !== undefined) {
+            // Only strip if the signature is in the latter half of the message
+            if (match.index > body.length * 0.3) {
+                body = body.slice(0, match.index);
+            }
+        }
+    }
+    // Remove stray partial HTML tags at the end of the body
+    body = body.replace(/<\w+\s*$/, "");
+    // Remove any remaining HTML tags that slipped through
+    body = body.replace(/<[^>]+>/g, "");
+    // Collapse 3+ consecutive newlines into 2
+    body = body.replace(/\n{3,}/g, "\n\n");
+    return body.trim();
+}
+/**
+ * Format an address object from mailparser into "Name <email>" or just "email".
+ */
+function formatAddress(addr) {
+    if (!addr?.value?.[0])
+        return "Unknown";
+    const a = addr.value[0];
+    if (a.name)
+        return a.name;
+    return a.address ?? "Unknown";
+}
+/**
+ * Render the thread as markdown.
+ */
+function renderMarkdown(parsed, messages, opts) {
+    const subject = parsed.subject ?? "Untitled Thread";
+    const participants = new Map();
+    for (const m of messages) {
+        participants.set(m.from, true);
+    }
+    const dates = messages.filter((m) => m.date).map((m) => m.date);
+    const minDate = dates.length > 0 ? formatDate(new Date(Math.min(...dates.map((d) => d.getTime())))) : "unknown";
+    const maxDate = dates.length > 0 ? formatDate(new Date(Math.max(...dates.map((d) => d.getTime())))) : "unknown";
+    const lines = [];
+    lines.push(`# ${subject}`);
+    lines.push("");
+    lines.push(`**Participants:** ${[...participants.keys()].join(", ")}`);
+    lines.push(`**Date range:** ${minDate} to ${maxDate}`);
+    lines.push(`**Messages:** ${messages.length}`);
+    if (opts.attachments && parsed.attachments?.length) {
+        lines.push("");
+        lines.push("**Attachments:**");
+        for (const att of parsed.attachments) {
+            const size = att.size ? `(${formatSize(att.size)})` : "";
+            lines.push(`- ${att.filename ?? "unnamed"} ${size}`);
+        }
+    }
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        const dateStr = m.date ? formatDateTime(m.date) : "unknown date";
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+        lines.push(`## ${i + 1}. ${m.from} - ${dateStr}`);
+        lines.push("");
+        lines.push(m.body);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function formatDate(d) {
+    return d.toISOString().slice(0, 10);
+}
+function formatDateTime(d) {
+    return d.toLocaleString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+        timeZone: "America/Chicago",
+    });
+}
+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`;
+}

package/dist/commands/env.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+export declare function registerEnvCommand(program: Command, emit: EmitContext, context?: HarneryProgramContext): void;
+//# sourceMappingURL=env.d.ts.map

package/dist/commands/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/commands/env.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAqB1E,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CAaN"}

package/dist/commands/env.js

@@ -0,0 +1,201 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { exec, sh } from "../lib/exec.js";
+export function registerEnvCommand(program, emit, context) {
+    program
+        .command("env [section]")
+        .description("Show environment status (docker, gcp, bq, node, python, git)")
+        .action(async (section) => {
+        try {
+            await handleEnv(section, emit, context);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            emit.error({ code: "env_error", message: msg });
+            process.exit(1);
+        }
+    });
+}
+async function handleEnv(section, emit, context) {
+    const sections = {
+        runtimes: checkRuntimes,
+        docker: checkDocker,
+        gcp: checkGcp,
+        bq: checkBigQuery,
+        git: () => checkGit(context),
+    };
+    if (section) {
+        const fn = sections[section];
+        if (!fn) {
+            emit.error({
+                code: "unknown_section",
+                message: `Unknown section "${section}". Valid: ${Object.keys(sections).join(", ")}`,
+            });
+            process.exit(1);
+        }
+        const checks = await fn();
+        emit.data({ ok: true, section, checks: checks.map(toRow) });
+        return;
+    }
+    const results = await Promise.all(Object.entries(sections).map(async ([name, fn]) => ({
+        name,
+        checks: await fn().catch(() => [
+            { label: name, value: "check failed", status: "missing" },
+        ]),
+    })));
+    emit.data({
+        ok: true,
+        sections: Object.fromEntries(results.map(({ name, checks }) => [name, checks.map(toRow)])),
+    });
+}
+function toRow(check) {
+    return { label: check.label, value: check.value };
+}
+async function checkRuntimes() {
+    const checks = [];
+    const [node, bun, python, php] = await Promise.all([
+        exec(["node", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+        exec(["bun", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+        exec(["python3", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+        exec(["php", "--version"]).catch(() => ({ stdout: "", exitCode: 1, stderr: "" })),
+    ]);
+    if (node.exitCode === 0)
+        checks.push({ label: "Node.js", value: node.stdout, status: "ok" });
+    else
+        checks.push({ label: "Node.js", value: "not found", status: "missing" });
+    if (bun.exitCode === 0)
+        checks.push({ label: "Bun", value: bun.stdout, status: "ok" });
+    else
+        checks.push({ label: "Bun", value: "not found", status: "missing" });
+    if (python.exitCode === 0)
+        checks.push({ label: "Python", value: python.stdout.replace("Python ", ""), status: "ok" });
+    else
+        checks.push({ label: "Python", value: "not found", status: "missing" });
+    if (php.exitCode === 0) {
+        const ver = php.stdout.split("\n")[0]?.match(/PHP (\S+)/)?.[1] ?? php.stdout;
+        checks.push({ label: "PHP", value: ver, status: "ok" });
+    }
+    else {
+        checks.push({ label: "PHP", value: "not found", status: "info" });
+    }
+    return checks;
+}
+async function checkDocker() {
+    const checks = [];
+    const dockerVersion = await exec(["docker", "--version"]).catch(() => ({
+        stdout: "",
+        exitCode: 1,
+        stderr: "",
+    }));
+    if (dockerVersion.exitCode !== 0) {
+        return [{ label: "Docker", value: "not installed", status: "missing" }];
+    }
+    const ver = dockerVersion.stdout.match(/Docker version (\S+)/)?.[1] ?? dockerVersion.stdout;
+    checks.push({ label: "Docker", value: ver, status: "ok" });
+    const ps = await sh('docker ps --format "{{.Names}}" 2>/dev/null').catch(() => ({
+        stdout: "",
+        exitCode: 1,
+        stderr: "",
+    }));
+    if (ps.exitCode === 0) {
+        const names = ps.stdout.split("\n").filter(Boolean);
+        checks.push({
+            label: "Containers",
+            value: names.length > 0 ? `${names.length} running` : "none running",
+            status: names.length > 0 ? "ok" : "info",
+        });
+    }
+    else {
+        checks.push({ label: "Containers", value: "docker ps unavailable", status: "info" });
+    }
+    return checks;
+}
+async function checkGcp() {
+    const checks = [];
+    const account = await sh("gcloud config get-value account 2>/dev/null").catch(() => ({
+        stdout: "",
+        exitCode: 1,
+        stderr: "",
+    }));
+    const project = await sh("gcloud config get-value project 2>/dev/null").catch(() => ({
+        stdout: "",
+        exitCode: 1,
+        stderr: "",
+    }));
+    if (account.exitCode === 0 && account.stdout) {
+        checks.push({ label: "GCP Account", value: account.stdout, status: "ok" });
+    }
+    else {
+        checks.push({ label: "GCP Account", value: "not authenticated", status: "missing" });
+    }
+    if (project.exitCode === 0 && project.stdout) {
+        checks.push({ label: "GCP Project", value: project.stdout, status: "ok" });
+    }
+    else {
+        checks.push({ label: "GCP Project", value: "not set", status: "missing" });
+    }
+    return checks;
+}
+async function checkBigQuery() {
+    const checks = [];
+    const result = await sh("bq ls --max_results=1 2>/dev/null").catch(() => ({
+        stdout: "",
+        exitCode: 1,
+        stderr: "",
+    }));
+    if (result.exitCode === 0) {
+        checks.push({ label: "BigQuery", value: "connected", status: "ok" });
+    }
+    else {
+        checks.push({ label: "BigQuery", value: "not connected (check GCP auth)", status: "missing" });
+    }
+    const datasets = await sh("bq ls --format=json --max_results=20 2>/dev/null").catch(() => ({
+        stdout: "",
+        exitCode: 1,
+        stderr: "",
+    }));
+    if (datasets.exitCode === 0 && datasets.stdout) {
+        try {
+            const ds = JSON.parse(datasets.stdout);
+            const names = ds
+                .map((d) => d.datasetReference?.datasetId)
+                .filter(Boolean)
+                .join(", ");
+            if (names)
+                checks.push({ label: "Datasets", value: names, status: "info" });
+        }
+        catch {
+            // Ignore parse failures
+        }
+    }
+    return checks;
+}
+async function checkGit(context) {
+    const checks = [];
+    const cwd = context?.repoRoot ?? process.cwd();
+    const branch = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+    checks.push({ label: "Branch", value: branch.stdout, status: "info" });
+    if (context?.repoRoot && context.submodules && context.submodules.length > 0) {
+        const initialized = context.submodules.filter((name) => isSubmoduleInitialized(resolve(context.repoRoot, name)));
+        const total = context.submodules.length;
+        checks.push({
+            label: "Submodules",
+            value: `${initialized.length}/${total} initialized`,
+            status: initialized.length === total ? "ok" : "warn",
+        });
+    }
+    return checks;
+}
+function isSubmoduleInitialized(dir) {
+    if (!existsSync(dir))
+        return false;
+    try {
+        // readdirSync lists every entry (dotfiles included, `.`/`..` excluded):
+        // the non-recursive "is this dir non-empty?" check this needs, on both
+        // Bun and Node (replaces the Bun-only `new Bun.Glob("*").scanSync`).
+        return readdirSync(dir).length > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/fetch.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+export declare function registerFetchCommand(program: Command, emit: EmitContext, context?: HarneryProgramContext): void;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/commands/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/commands/fetch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AA4B1E,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CA2BN"}