@gethmy/agent 1.0.8 → 1.1.0

package/dist/config-validation.js

@@ -0,0 +1,66 @@
+import { log } from "./log.js";
+const TAG = "config-validation";
+export class ConfigValidationError extends Error {
+    issues;
+    constructor(message, issues) {
+        super(message);
+        this.issues = issues;
+        this.name = "ConfigValidationError";
+    }
+}
+function columnNames(board) {
+    return board.columns.map((c) => c.name);
+}
+function findColumn(board, name) {
+    const target = name.toLowerCase();
+    return board.columns.some((c) => c.name.toLowerCase() === target);
+}
+/**
+ * Validate that every column referenced in the agent config actually
+ * exists on the board. Labels that the daemon needs to create (agent,
+ * Ready to Merge, Merged, Need Review, agent-recovered) are not
+ * required to pre-exist — the daemon creates them on demand. Columns
+ * must already exist because moving a card to a non-existent column
+ * silently fails and leaves cards stuck.
+ *
+ * Fail-fast on any mismatch: the operator fixes their config OR the
+ * board before the daemon is useful.
+ */
+export async function validateColumnReferences(client, projectId, config) {
+    const board = (await client.getBoard(projectId, {
+        summary: true,
+    }));
+    const known = columnNames(board);
+    const issues = [];
+    const required = [
+        ...config.pickupColumns.map((c) => ({ value: c, where: "pickupColumns" })),
+        {
+            value: config.completion.moveToColumn,
+            where: "completion.moveToColumn",
+        },
+        {
+            value: config.verification.failColumn,
+            where: "verification.failColumn",
+        },
+    ];
+    if (config.review.enabled) {
+        for (const c of config.review.pickupColumns) {
+            required.push({ value: c, where: "review.pickupColumns" });
+        }
+        required.push({ value: config.review.moveToColumn, where: "review.moveToColumn" }, { value: config.review.failColumn, where: "review.failColumn" });
+    }
+    for (const { value, where } of required) {
+        if (!value)
+            continue;
+        if (!findColumn(board, value)) {
+            issues.push(`${where}: column "${value}" not found on board`);
+        }
+    }
+    if (issues.length > 0) {
+        const help = `Available columns: ${known.join(", ")}`;
+        throw new ConfigValidationError(`Invalid agent config — the following columns are missing:\n  - ${issues.join("\n  - ")}\n${help}`, issues);
+    }
+    log.info(TAG, `Validated columns: ${Array.from(new Set(required.map((r) => r.value)))
+        .filter(Boolean)
+        .join(", ")}`);
+}

package/dist/config.js

@@ -70,6 +70,18 @@ export function loadDaemonConfig() {
             ...DEFAULT_AGENT_CONFIG.review,
             ...(agentOverrides.review ?? {}),
         },
+        budget: {
+            ...DEFAULT_AGENT_CONFIG.budget,
+            ...(agentOverrides.budget ?? {}),
+        },
+        http: {
+            ...DEFAULT_AGENT_CONFIG.http,
+            ...(agentOverrides.http ?? {}),
+        },
+        timing: {
+            ...DEFAULT_AGENT_CONFIG.timing,
+            ...(agentOverrides.timing ?? {}),
+        },
     };
     return { apiKey, apiUrl, workspaceId, projectId, userEmail, agent };
 }

package/dist/http-server.d.ts

@@ -0,0 +1,79 @@
+export interface HealthSnapshot {
+    healthy: boolean;
+    checks: Record<string, boolean>;
+}
+export interface WorkerSnapshot {
+    id: number;
+    pipeline: "implement" | "review";
+    state: string;
+    cardId: string | null;
+    cardShortId: number | null;
+    phase: string | null;
+    startedAt: number | null;
+    branchName: string | null;
+}
+export interface StatusSnapshot {
+    daemonId: string;
+    daemonPid: number;
+    startedAt: number;
+    uptimeMs: number;
+    workers: WorkerSnapshot[];
+    implQueue: Array<{
+        cardId: string;
+        shortId: number;
+        priority: number;
+        enqueuedAt: number;
+    }>;
+    reviewQueue: Array<{
+        cardId: string;
+        shortId: number;
+        priority: number;
+        enqueuedAt: number;
+    }>;
+    dlq: Array<{
+        cardId: string;
+        reason: string;
+        attempts: number;
+        totalCostCents: number;
+    }>;
+    budget: {
+        todayCents: number;
+        dailyCapCents: number;
+    };
+}
+export type Command = "pause" | "resume" | "stop";
+export interface HttpServerOptions {
+    port: number;
+    bindAddr: string;
+    getStatus: () => StatusSnapshot;
+    getHealth: () => HealthSnapshot;
+    handleCommand: (cmd: Command, cardId: string) => Promise<void>;
+    /**
+     * Clear a card's DLQ marker. Routed through the daemon (not CLI
+     * direct-write) so we never have two processes racing to persist
+     * the same state-store file.
+     */
+    clearDlq: (cardId: string) => Promise<void>;
+}
+/**
+ * Tiny introspection + control surface for the running daemon.
+ * Binds to 127.0.0.1 by default so it's not network-reachable.
+ *
+ * GET /health — 200 when healthy, 503 otherwise. Simple liveness check
+ *   suitable for process supervisors (systemd, pm2, docker healthcheck).
+ * GET /status — full JSON snapshot: workers, queues, DLQ, budget.
+ * POST /pause/:cardId, /resume/:cardId, /stop/:cardId — command path
+ *   so an operator can nudge a stuck worker without killing the daemon.
+ */
+export declare class HttpServer {
+    private opts;
+    private server;
+    constructor(opts: HttpServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private route;
+    private respondDlqClear;
+    private respondHealth;
+    private respondStatus;
+    private respondCommand;
+}

package/dist/http-server.js

@@ -0,0 +1,115 @@
+import { createServer, } from "node:http";
+import { log } from "./log.js";
+const TAG = "http";
+/**
+ * Tiny introspection + control surface for the running daemon.
+ * Binds to 127.0.0.1 by default so it's not network-reachable.
+ *
+ * GET /health — 200 when healthy, 503 otherwise. Simple liveness check
+ *   suitable for process supervisors (systemd, pm2, docker healthcheck).
+ * GET /status — full JSON snapshot: workers, queues, DLQ, budget.
+ * POST /pause/:cardId, /resume/:cardId, /stop/:cardId — command path
+ *   so an operator can nudge a stuck worker without killing the daemon.
+ */
+export class HttpServer {
+    opts;
+    server = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => {
+                this.route(req, res).catch((err) => {
+                    log.error(TAG, `unhandled: ${err instanceof Error ? err.message : err}`);
+                    if (!res.headersSent) {
+                        res.writeHead(500, { "content-type": "application/json" });
+                        res.end(JSON.stringify({ error: "internal_error" }));
+                    }
+                });
+            });
+            this.server.once("error", reject);
+            this.server.listen(this.opts.port, this.opts.bindAddr, () => {
+                log.info(TAG, `listening on http://${this.opts.bindAddr}:${this.opts.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.server)
+            return;
+        await new Promise((resolve) => {
+            this.server?.close(() => resolve());
+        });
+        this.server = null;
+    }
+    async route(req, res) {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const method = (req.method ?? "GET").toUpperCase();
+        const path = url.pathname;
+        if (method === "GET" && path === "/health") {
+            return this.respondHealth(res);
+        }
+        if (method === "GET" && path === "/status") {
+            return this.respondStatus(res);
+        }
+        if (method === "POST") {
+            const dlq = path.match(/^\/dlq\/clear\/([^/]+)$/);
+            if (dlq) {
+                return this.respondDlqClear(res, decodeURIComponent(dlq[1]));
+            }
+            const cmd = parseCommand(path);
+            if (cmd) {
+                return this.respondCommand(res, cmd.command, cmd.cardId);
+            }
+        }
+        res.writeHead(404, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "not_found", path }));
+    }
+    async respondDlqClear(res, cardId) {
+        try {
+            await this.opts.clearDlq(cardId);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, cardId }));
+        }
+        catch (err) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                error: "clear_dlq_failed",
+                detail: err instanceof Error ? err.message : String(err),
+            }));
+        }
+    }
+    respondHealth(res) {
+        const health = this.opts.getHealth();
+        res.writeHead(health.healthy ? 200 : 503, {
+            "content-type": "application/json",
+        });
+        res.end(JSON.stringify(health));
+    }
+    respondStatus(res) {
+        const snapshot = this.opts.getStatus();
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(snapshot));
+    }
+    async respondCommand(res, command, cardId) {
+        try {
+            await this.opts.handleCommand(command, cardId);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, command, cardId }));
+        }
+        catch (err) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                error: "command_failed",
+                detail: err instanceof Error ? err.message : String(err),
+            }));
+        }
+    }
+}
+function parseCommand(path) {
+    const match = path.match(/^\/(pause|resume|stop)\/([^/]+)$/);
+    if (!match)
+        return null;
+    return { command: match[1], cardId: decodeURIComponent(match[2]) };
+}

package/dist/index.d.ts

@@ -1 +1,4 @@
-export {};
+import { type DaemonConfig } from "./config.js";
+declare function validatePrerequisites(config: DaemonConfig): Promise<string>;
+export { validatePrerequisites };
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -1,12 +1,19 @@
 import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { buildLabelMap, hasLabel, resolveCardLabels } from "./board-helpers.js";
 import { createApiClient, fetchRealtimeCredentials, loadDaemonConfig, } from "./config.js";
+import { ConfigValidationError, validateColumnReferences, } from "./config-validation.js";
 import { detectGitProvider, validateGitProviderCli } from "./git-pr.js";
+import { HttpServer } from "./http-server.js";
 import { log } from "./log.js";
 import { MergeMonitor } from "./merge-monitor.js";
 import { Pool } from "./pool.js";
 import { Reconciler } from "./reconcile.js";
+import { recoverOrphans } from "./recovery.js";
+import { extractBranchFromDescription } from "./review-worktree.js";
+import { StateStore } from "./state-store.js";
 import { Watcher } from "./watcher.js";
+import { WorktreeGc } from "./worktree-gc.js";
 const TAG = "daemon";
 // ============ STARTUP VALIDATION ============
 async function validatePrerequisites(config) {
@@ -70,7 +77,8 @@ async function validatePrerequisites(config) {
     return agentMember.userId;
 }
 // ============ MAIN DAEMON ============
-async function main() {
+export { validatePrerequisites };
+export async function main() {
     log.info(TAG, "Harmony Agent Daemon starting...");
     // Load config
     const config = loadDaemonConfig();
@@ -83,11 +91,32 @@ async function main() {
     log.info(TAG, `Agent user: ${config.userEmail} (${agentUserId})`);
     // Create API client
     const client = createApiClient(config);
+    // Fail fast if configured columns don't exist on the board. A stuck
+    // card with no log output is worse than a clear startup error.
+    try {
+        await validateColumnReferences(client, config.projectId, config.agent);
+    }
+    catch (err) {
+        if (err instanceof ConfigValidationError) {
+            log.error(TAG, err.message);
+            process.exit(1);
+        }
+        throw err;
+    }
+    // Durable run/card state lives outside the process. Recover orphans
+    // from any crashed prior daemon BEFORE we start accepting new work.
+    const stateStore = StateStore.open();
+    const daemonId = randomUUID();
+    await stateStore.setDaemon(daemonId, process.pid);
+    const outcomes = await recoverOrphans(stateStore, client, config.agent);
+    if (outcomes.length > 0) {
+        log.info(TAG, `recovery: ${outcomes.length} orphan(s) handled, ${outcomes.filter((o) => o.errors.length).length} had errors`);
+    }
     // Fetch realtime credentials
     const realtimeCreds = await fetchRealtimeCredentials(client);
     log.info(TAG, "Realtime credentials fetched");
     // Create pool
-    const pool = new Pool(config.agent, client, config.userEmail, config.workspaceId, config.projectId);
+    const pool = new Pool(config.agent, client, config.userEmail, config.workspaceId, config.projectId, stateStore);
     // Create reconciler
     const reviewColumns = config.agent.review.enabled
         ? config.agent.review.pickupColumns
@@ -95,12 +124,74 @@ async function main() {
     const approvedLabel = config.agent.review.enabled
         ? config.agent.review.approvedLabel
         : "";
-    const reconciler = new Reconciler(client, pool, config.projectId, agentUserId, config.agent.pickupColumns, reviewColumns, approvedLabel, 60_000);
+    const reconciler = new Reconciler(client, pool, config.projectId, agentUserId, config.agent.pickupColumns, reviewColumns, approvedLabel, config.agent.timing.reconcileIntervalMs, stateStore, config.agent);
     // Create merge monitor (polls PR merge status for "Ready to Merge" cards)
     let mergeMonitor = null;
     if (config.agent.review.enabled && config.agent.review.mergeMonitor) {
         mergeMonitor = new MergeMonitor(client, config.projectId, config.agent);
     }
+    // Periodic worktree GC — removes orphan worktrees older than 1h that
+    // no active run claims. Covers crashes that left worktrees behind.
+    const worktreeGc = new WorktreeGc(config.agent.worktree.basePath, stateStore, config.agent.timing.worktreeGcIntervalMs);
+    // Local status/control HTTP server.
+    const startedAt = Date.now();
+    const httpServer = config.agent.http.enabled
+        ? new HttpServer({
+            port: config.agent.http.port,
+            bindAddr: config.agent.http.bindAddr,
+            getHealth: () => {
+                const lastTick = reconciler.lastTick;
+                const reconcilerFresh = lastTick !== null &&
+                    Date.now() - lastTick < config.agent.timing.reconcileIntervalMs * 2;
+                const checks = {
+                    watcher: watcher.isConnected,
+                    reconciler: reconciler.isRunning && reconcilerFresh,
+                };
+                return {
+                    healthy: Object.values(checks).every(Boolean),
+                    checks,
+                };
+            },
+            getStatus: () => {
+                const queues = pool.snapshotQueues();
+                const dlq = stateStore.listDlq().map((c) => ({
+                    cardId: c.cardId,
+                    reason: c.dlqReason ?? "unknown",
+                    attempts: c.attempts,
+                    totalCostCents: c.totalCostCents,
+                }));
+                return {
+                    daemonId,
+                    daemonPid: process.pid,
+                    startedAt,
+                    uptimeMs: Date.now() - startedAt,
+                    workers: pool.snapshotWorkers().map((w) => ({
+                        ...w,
+                        phase: null,
+                    })),
+                    implQueue: queues.impl.map((i) => ({
+                        cardId: i.cardId,
+                        shortId: i.shortId,
+                        priority: i.priority,
+                        enqueuedAt: i.enqueuedAt,
+                    })),
+                    reviewQueue: queues.review.map((i) => ({
+                        cardId: i.cardId,
+                        shortId: i.shortId,
+                        priority: i.priority,
+                        enqueuedAt: i.enqueuedAt,
+                    })),
+                    dlq,
+                    budget: {
+                        todayCents: stateStore.getDailyCostCents(),
+                        dailyCapCents: config.agent.budget.dailyBudgetCents,
+                    },
+                };
+            },
+            handleCommand: (cmd, cardId) => pool.handleAgentCommand(cardId, cmd),
+            clearDlq: (cardId) => stateStore.clearDlq(cardId),
+        })
+        : null;
     // Create watcher (broadcast events from harmony-api + agent commands from UI)
     const watcher = new Watcher(realtimeCreds, config.projectId, async (event) => {
         await handleBroadcast(event, client, pool, config, agentUserId);
@@ -109,6 +200,7 @@ async function main() {
     });
     // Wire up shutdown
     let shuttingDown = false;
+    let exitCode = 0;
     const shutdown = async (signal) => {
         if (shuttingDown)
             return;
@@ -116,17 +208,38 @@ async function main() {
         log.info(TAG, `Received ${signal}, shutting down gracefully...`);
         reconciler.stop();
         mergeMonitor?.stop();
+        worktreeGc.stop();
+        await httpServer?.stop();
         await watcher.stop();
         await pool.shutdown();
         log.info(TAG, "Daemon stopped.");
-        process.exit(0);
+        process.exit(exitCode);
     };
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("uncaughtException", (err) => {
+        log.error(TAG, `Uncaught exception: ${err.message}`);
+        exitCode = 1;
+        shutdown("uncaughtException");
+    });
+    process.on("unhandledRejection", (reason) => {
+        log.error(TAG, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+        exitCode = 1;
+        shutdown("unhandledRejection");
+    });
     // Start everything
     await watcher.start();
     reconciler.start();
     mergeMonitor?.start();
+    worktreeGc.start();
+    if (httpServer) {
+        try {
+            await httpServer.start();
+        }
+        catch (err) {
+            log.warn(TAG, `HTTP server failed to bind: ${err instanceof Error ? err.message : err}`);
+        }
+    }
     log.info(TAG, "Daemon is running. Watching for card assignments...");
 }
 // ============ EVENT HANDLER ============
@@ -190,10 +303,12 @@ async function tryEnqueueCard(cardId, client, pool, config) {
         log.debug(TAG, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
         return;
     }
-    pool.enqueue(card, column, cardLabels, subtasks, mode);
+    // Skip review for cards without a branch reference — not qualified for auto-review
+    if (mode === "review" && !extractBranchFromDescription(card.description)) {
+        log.info(TAG, `Card #${card.short_id} has no branch reference — skipping auto-review`);
+        return;
+    }
+    await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-// ============ RUN ============
-main().catch((err) => {
-    log.error(TAG, `Fatal: ${err instanceof Error ? err.message : err}`);
-    process.exit(1);
-});
+// The daemon is now launched from cli.ts so other subcommands
+// (status, doctor, gc, dlq) can load this module without side effects.

package/dist/log.d.ts

@@ -1,10 +1,34 @@
 /**
  * Structured logging for the agent daemon.
- * Always logs to stderr so stdout stays clean for potential piping.
+ *
+ * When stderr is a TTY, output is ANSI-coloured single-line text — the
+ * readable default for humans running the daemon interactively. When
+ * stderr is piped/redirected (files, logshippers, systemd), output
+ * falls back to one JSON object per line — trivially `jq`-able,
+ * indexable, and machine-readable.
+ *
+ * Overrides: `--pretty` / HARMONY_AGENT_PRETTY=1 force pretty;
+ * `--json`   / HARMONY_AGENT_JSON=1   force JSON. Explicit flags beat
+ * TTY detection either way.
+ *
+ * Stdout is left clean so consumers can pipe structured data if they
+ * want to (future use).
  */
+export interface LogContext {
+    event?: string;
+    runId?: string;
+    cardId?: string;
+    [key: string]: unknown;
+}
 export declare const log: {
-    info(tag: string, msg: string): void;
-    warn(tag: string, msg: string): void;
-    error(tag: string, msg: string): void;
-    debug(tag: string, msg: string): void;
+    info(tag: string, msg: string, ctx?: LogContext): void;
+    warn(tag: string, msg: string, ctx?: LogContext): void;
+    error(tag: string, msg: string, ctx?: LogContext): void;
+    debug(tag: string, msg: string, ctx?: LogContext): void;
+    /**
+     * Emit a named event. Semantically the same as `info` but signals to
+     * downstream tooling that this is a structured event worth indexing.
+     */
+    event(tag: string, event: string, ctx?: LogContext): void;
 };
+export declare function isPretty(): boolean;

package/dist/log.js

@@ -1,6 +1,18 @@
 /**
  * Structured logging for the agent daemon.
- * Always logs to stderr so stdout stays clean for potential piping.
+ *
+ * When stderr is a TTY, output is ANSI-coloured single-line text — the
+ * readable default for humans running the daemon interactively. When
+ * stderr is piped/redirected (files, logshippers, systemd), output
+ * falls back to one JSON object per line — trivially `jq`-able,
+ * indexable, and machine-readable.
+ *
+ * Overrides: `--pretty` / HARMONY_AGENT_PRETTY=1 force pretty;
+ * `--json`   / HARMONY_AGENT_JSON=1   force JSON. Explicit flags beat
+ * TTY detection either way.
+ *
+ * Stdout is left clean so consumers can pipe structured data if they
+ * want to (future use).
  */
 const COLORS = {
     reset: "\x1b[0m",
@@ -11,25 +23,78 @@ const COLORS = {
     blue: "\x1b[34m",
     cyan: "\x1b[36m",
 };
-function timestamp() {
-    return new Date().toISOString().slice(11, 23);
+const LEVEL_COLOR = {
+    debug: COLORS.dim,
+    info: COLORS.green,
+    warn: COLORS.yellow,
+    error: COLORS.red,
+};
+function pretty() {
+    if (process.env.HARMONY_AGENT_JSON === "1" ||
+        process.argv.includes("--json")) {
+        return false;
+    }
+    if (process.env.HARMONY_AGENT_PRETTY === "1")
+        return true;
+    if (process.argv.includes("--pretty"))
+        return true;
+    return Boolean(process.stderr.isTTY);
+}
+function shortTime(iso) {
+    return iso.slice(11, 23);
+}
+function emit(rec) {
+    if (rec.level === "debug" && !process.env.DEBUG)
+        return;
+    if (pretty()) {
+        const color = LEVEL_COLOR[rec.level];
+        const label = rec.level.toUpperCase().padEnd(5, " ");
+        const ctx = [];
+        if (rec.event)
+            ctx.push(`event=${rec.event}`);
+        if (rec.runId)
+            ctx.push(`run=${rec.runId}`);
+        if (rec.cardId)
+            ctx.push(`card=${rec.cardId}`);
+        const tail = ctx.length
+            ? ` ${COLORS.dim}(${ctx.join(" ")})${COLORS.reset}`
+            : "";
+        process.stderr.write(`${COLORS.dim}${shortTime(rec.ts)}${COLORS.reset} ${color}${label}${COLORS.reset} ${COLORS.cyan}[${rec.tag}]${COLORS.reset} ${rec.msg}${tail}\n`);
+        return;
+    }
+    process.stderr.write(`${JSON.stringify(rec)}\n`);
 }
-function fmt(level, color, tag, msg) {
-    return `${COLORS.dim}${timestamp()}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${tag}]${COLORS.reset} ${msg}`;
+function record(level, tag, msg, ctx) {
+    const rec = {
+        ts: new Date().toISOString(),
+        level,
+        tag,
+        msg,
+        ...(ctx ?? {}),
+    };
+    emit(rec);
 }
 export const log = {
-    info(tag, msg) {
-        console.error(fmt("INFO ", COLORS.green, tag, msg));
+    info(tag, msg, ctx) {
+        record("info", tag, msg, ctx);
     },
-    warn(tag, msg) {
-        console.error(fmt("WARN ", COLORS.yellow, tag, msg));
+    warn(tag, msg, ctx) {
+        record("warn", tag, msg, ctx);
     },
-    error(tag, msg) {
-        console.error(fmt("ERROR", COLORS.red, tag, msg));
+    error(tag, msg, ctx) {
+        record("error", tag, msg, ctx);
     },
-    debug(tag, msg) {
-        if (process.env.DEBUG) {
-            console.error(fmt("DEBUG", COLORS.dim, tag, msg));
-        }
+    debug(tag, msg, ctx) {
+        record("debug", tag, msg, ctx);
+    },
+    /**
+     * Emit a named event. Semantically the same as `info` but signals to
+     * downstream tooling that this is a structured event worth indexing.
+     */
+    event(tag, event, ctx) {
+        record("info", tag, event, { ...ctx, event });
     },
 };
+export function isPretty() {
+    return pretty();
+}