@webywz/vibe-commit 0.0.0-stage → 0.1.1

package/dist/heuristic.js

@@ -0,0 +1,336 @@
+import { normalizeSubject } from "./format.js";
+import { applyVibe } from "./vibe.js";
+const SKIP_SCOPE_DIRS = new Set([
+    ".",
+    "src",
+    "lib",
+    "app",
+    "apps",
+    "dist",
+    "build",
+    "source",
+    "sources",
+    "packages",
+    "test",
+    "tests",
+    "__tests__",
+    "bin",
+    "scripts",
+]);
+const IDENT_RE = /^\+\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:pub(?:lic|\(crate\))?\s+)?(?:function|const|let|class|type|interface|enum|fn|struct|trait|impl|def|func)\s+([A-Za-z_][\w]*)/;
+const FIX_WORD_RE = /\b(fix|fixed|fixes|bug|bugs|hotfix|crash|broken|error|regression|issue|#\d+)\b/i;
+const FEAT_WORD_RE = /\b(add|added|feat|feature|implement|introduce|support|enable)\b/i;
+const REFACTOR_WORD_RE = /\b(refactor|rename|move|extract|simplify|cleanup|clean up|restructure)\b/i;
+const PERF_WORD_RE = /\b(perf|performance|optimiz|cache|faster|speed)\b/i;
+export function proposeHeuristic(input) {
+    const { diff, vibe } = input;
+    const type = input.type ?? inferType(diff);
+    const scope = input.scope ?? inferScope(diff.files);
+    const subject = inferSubject(diff, type, scope);
+    const body = inferBody(diff, type);
+    const breaking = inferBreaking(diff);
+    const styled = applyVibe({ type, scope, subject, body, breaking }, vibe);
+    return { ...styled, engine: "heuristic" };
+}
+export function inferType(diff) {
+    const files = diff.files;
+    if (files.length === 0)
+        return "chore";
+    const roles = files.map((file) => primaryRole(file.path));
+    const unique = new Set(roles);
+    const keyword = keywordType(diff);
+    if (unique.size === 1) {
+        const role = roles[0] ?? "chore";
+        if (role !== "feat")
+            return role;
+        if (files.every((file) => file.status === "R"))
+            return "refactor";
+        return keyword ?? "feat";
+    }
+    if (keyword === "fix" || keyword === "perf" || keyword === "refactor") {
+        return keyword;
+    }
+    const codeRoles = roles.filter((role) => role === "feat" || role === "style" || role === "build");
+    if (codeRoles.length > 0)
+        return "feat";
+    if (roles.includes("test"))
+        return "test";
+    if (roles.includes("ci"))
+        return "ci";
+    if (roles.includes("docs"))
+        return "docs";
+    return "chore";
+}
+export function primaryRole(path) {
+    if (isTestPath(path))
+        return "test";
+    if (isCiPath(path))
+        return "ci";
+    if (isDocsPath(path))
+        return "docs";
+    if (isBuildPath(path))
+        return "build";
+    if (isChorePath(path))
+        return "chore";
+    if (isStylePath(path))
+        return "style";
+    return "feat";
+}
+export function classifyPath(path) {
+    return [primaryRole(path)];
+}
+function isTestPath(path) {
+    return (/(^|\/)(__tests__|tests?|spec)\//i.test(path) ||
+        /\.(tests?|spec)\.[cm]?[jt]sx?$/i.test(path));
+}
+function isCiPath(path) {
+    return /(^|\/)(\.github\/workflows|\.gitlab-ci|\.circleci)(\/|$)/i.test(path);
+}
+function isDocsPath(path) {
+    return (/(^|\/)(docs?|documentation)\//i.test(path) ||
+        /\.(md|mdx|rst|adoc)$/i.test(path) ||
+        /readme/i.test(path));
+}
+function isBuildPath(path) {
+    return /(^|\/)(Dockerfile|Makefile|webpack\.|vite\.config|rollup\.config|tsup\.config|esbuild)/i.test(path);
+}
+function isChorePath(path) {
+    return /(^|\/)(\.gitignore|\.editorconfig|\.nvmrc|eslint|prettier|tsconfig|package(-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)(\b|$)/i.test(path);
+}
+function isStylePath(path) {
+    return /\.(css|scss|sass|less)$/i.test(path);
+}
+function keywordType(diff) {
+    const blob = keywordCorpus(diff);
+    if (FIX_WORD_RE.test(blob))
+        return "fix";
+    if (PERF_WORD_RE.test(blob))
+        return "perf";
+    if (REFACTOR_WORD_RE.test(blob))
+        return "refactor";
+    if (FEAT_WORD_RE.test(blob))
+        return "feat";
+    return undefined;
+}
+export function inferScope(files) {
+    if (files.length === 0)
+        return undefined;
+    const candidates = files
+        .map((file) => scopeFromPath(file.path))
+        .filter((value) => Boolean(value));
+    if (candidates.length === 0)
+        return undefined;
+    const counts = new Map();
+    for (const candidate of candidates) {
+        counts.set(candidate, (counts.get(candidate) ?? 0) + 1);
+    }
+    const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+    const top = ranked[0];
+    if (!top)
+        return undefined;
+    const [name, count] = top;
+    if (count / files.length < 0.5 && files.length > 2)
+        return undefined;
+    if (SKIP_SCOPE_DIRS.has(name))
+        return undefined;
+    return name.slice(0, 32);
+}
+export function inferSubject(diff, type, scope) {
+    const files = diff.files;
+    if (files.length === 0)
+        return "update project files";
+    const added = files.filter((file) => file.status === "A");
+    const deleted = files.filter((file) => file.status === "D");
+    const renamed = files.filter((file) => file.status === "R");
+    const idents = files.length <= 3 ? collectAddedIdentifiers(diff.hunks).slice(0, 2) : [];
+    if (added.length >= 4 &&
+        added.length >= files.length - 1 &&
+        !scope &&
+        type === "feat") {
+        return normalizeSubject("add initial implementation");
+    }
+    if (renamed.length === 1 && files.length === 1) {
+        const file = renamed[0];
+        return normalizeSubject(`rename ${stem(file.fromPath ?? file.path)} to ${stem(file.path)}`);
+    }
+    if (deleted.length === files.length) {
+        return normalizeSubject(`remove ${joinNames(deleted.map((file) => stem(file.path)))}`);
+    }
+    if (idents.length > 0 && (type === "feat" || type === "fix")) {
+        const verb = type === "fix" ? "fix" : "add";
+        return normalizeSubject(`${verb} ${joinNames(idents.map(humanizeIdent))}`);
+    }
+    if (added.length === 1 && files.length === 1) {
+        return normalizeSubject(`add ${stem(added[0].path)}`);
+    }
+    if (added.length > 1 && added.length === files.length) {
+        return normalizeSubject(`add ${summarizeFiles(added, scope)}`);
+    }
+    const focus = files.length === 1 ? stem(files[0].path) : summarizeFiles(files, scope);
+    return normalizeSubject(verbFor(type, focus, files));
+}
+function verbFor(type, focus, files) {
+    const mostlyAdd = files.reduce((sum, file) => sum + file.additions, 0) >
+        files.reduce((sum, file) => sum + file.deletions, 0) * 1.4;
+    switch (type) {
+        case "feat":
+            return mostlyAdd ? `add ${focus}` : `update ${focus}`;
+        case "fix":
+            return `fix ${focus}`;
+        case "docs":
+            return files.some((file) => /readme/i.test(file.path))
+                ? "update readme"
+                : `update ${focus}`;
+        case "test":
+            return mostlyAdd ? `add ${focus} tests` : `update ${focus} tests`;
+        case "refactor":
+            return `refactor ${focus}`;
+        case "perf":
+            return `improve ${focus} performance`;
+        case "style":
+            return `format ${focus}`;
+        case "ci":
+            return `update ${focus} workflow`;
+        case "build":
+            return `update ${focus} build`;
+        case "chore":
+            if (files.some((file) => /package(-lock)?\.json|pnpm-lock|yarn\.lock/.test(file.path))) {
+                return "update dependencies";
+            }
+            return `update ${focus}`;
+    }
+}
+function inferBody(diff, type) {
+    const files = diff.files;
+    if (files.length < 3)
+        return undefined;
+    const listed = files
+        .slice(0, 8)
+        .map((file) => `- ${statusLabel(file.status)} ${file.path}`)
+        .join("\n");
+    const extra = files.length > 8 ? `\n- …and ${files.length - 8} more` : "";
+    const lead = type === "feat"
+        ? "Touches:"
+        : type === "fix"
+            ? "Files in this fix:"
+            : "Changed files:";
+    return `${lead}\n${listed}${extra}`;
+}
+function inferBreaking(diff) {
+    return diff.hunks.some((hunk) => hunk.lines.some((line) => /^\+\s*BREAKING CHANGE:/i.test(line)));
+}
+export function collectAddedIdentifiers(hunks) {
+    const names = [];
+    const seen = new Set();
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (!line.startsWith("+") || line.startsWith("+++"))
+                continue;
+            const match = line.match(IDENT_RE);
+            if (!match?.[1])
+                continue;
+            const name = match[1];
+            if (seen.has(name) || name.length < 2)
+                continue;
+            seen.add(name);
+            names.push(name);
+        }
+    }
+    return names;
+}
+function scopeFromPath(path) {
+    const parts = path.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    if (parts[0] === "packages" && parts[1])
+        return sanitizeIdent(parts[1]);
+    const start = SKIP_SCOPE_DIRS.has(parts[0] ?? "") ? 1 : 0;
+    const candidate = parts[start];
+    if (!candidate)
+        return undefined;
+    if (parts.length < start + 2) {
+        if (parts.length === start + 1 &&
+            !candidate.startsWith(".") &&
+            !isDocsPath(path) &&
+            !isChorePath(path) &&
+            !isCiPath(path)) {
+            const name = sanitizeIdent(candidate.replace(/\.[^.]+$/, ""));
+            if (name && name !== "index")
+                return name;
+        }
+        return undefined;
+    }
+    if (SKIP_SCOPE_DIRS.has(candidate) || candidate.startsWith(".")) {
+        return undefined;
+    }
+    return sanitizeIdent(candidate.replace(/\.[^.]+$/, ""));
+}
+function sanitizeIdent(value) {
+    return value
+        .replace(/[^\w.-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+}
+export function stem(path) {
+    const parts = path.split("/").filter(Boolean);
+    let base = parts.at(-1) ?? path;
+    if (/^(index|main|mod|__init__)\.[^.]+$/i.test(base) && parts.length >= 2) {
+        base = parts.at(-2) ?? base;
+    }
+    base = base.replace(/\.(tests?|spec)\.[^.]+$/i, "");
+    base = base.replace(/\.[^.]+$/, "");
+    return humanizeIdent(base);
+}
+function humanizeIdent(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_./-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function joinNames(names) {
+    const unique = [...new Set(names.filter(Boolean))];
+    if (unique.length === 0)
+        return "files";
+    if (unique.length === 1)
+        return unique[0];
+    if (unique.length === 2)
+        return `${unique[0]} and ${unique[1]}`;
+    return `${unique[0]}, ${unique[1]}, and more`;
+}
+function summarizeFiles(files, scope) {
+    if (scope)
+        return scope;
+    return joinNames(files.map((file) => stem(file.path)).slice(0, 2));
+}
+function statusLabel(status) {
+    switch (status) {
+        case "A":
+            return "add";
+        case "D":
+            return "delete";
+        case "R":
+            return "rename";
+        default:
+            return "edit";
+    }
+}
+function keywordCorpus(diff) {
+    const paths = diff.files.map((file) => file.path).join("\n");
+    const onlyDocs = diff.files.every((file) => isDocsPath(file.path));
+    const docPaths = new Set(diff.files.filter((file) => isDocsPath(file.path)).map((file) => file.path));
+    const lines = [];
+    for (const hunk of diff.hunks) {
+        const fromDocs = onlyDocs && docPaths.has(hunk.path);
+        for (const line of hunk.lines) {
+            if (!line.startsWith("+") || line.startsWith("+++"))
+                continue;
+            if (fromDocs || /^\+\s*(?:\/\/|#|\/\*|\*|<!--)/.test(line)) {
+                lines.push(line);
+            }
+        }
+    }
+    return `${paths}\n${lines.join("\n")}`;
+}
+//# sourceMappingURL=heuristic.js.map

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { proposeWithAi } from "./ai.ts";
+export { formatCommit, parseCommit, normalizeSubject } from "./format.ts";
+export { inspectStaged, commitWithMessage, GitError } from "./git.ts";
+export { proposeHeuristic, inferType, inferScope, inferSubject, classifyPath, } from "./heuristic.ts";
+export { parseArgs, helpText, UsageError } from "./parse-args.ts";
+export { assembleDiff, parseUnifiedDiff } from "./parse-diff.ts";
+export { proposeMessage } from "./propose.ts";
+export { applyVibe } from "./vibe.ts";
+export type { CliOptions, CommitType, ProposedMessage, ProposeOptions, StagedDiff, StagedFile, Vibe, } from "./types.ts";
+export { COMMIT_TYPES, VIBES } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,10 @@
+export { proposeWithAi } from "./ai.js";
+export { formatCommit, parseCommit, normalizeSubject } from "./format.js";
+export { inspectStaged, commitWithMessage, GitError } from "./git.js";
+export { proposeHeuristic, inferType, inferScope, inferSubject, classifyPath, } from "./heuristic.js";
+export { parseArgs, helpText, UsageError } from "./parse-args.js";
+export { assembleDiff, parseUnifiedDiff } from "./parse-diff.js";
+export { proposeMessage } from "./propose.js";
+export { applyVibe } from "./vibe.js";
+export { COMMIT_TYPES, VIBES } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/parse-args.d.ts

@@ -0,0 +1,10 @@
+import { type CliOptions, type CommitType, type Vibe } from "./types.ts";
+export declare function defaultVibeFromEnv(env?: NodeJS.ProcessEnv): Vibe;
+export declare function parseArgs(argv: string[], env?: NodeJS.ProcessEnv): CliOptions;
+export declare function parseType(value: string | undefined): CommitType;
+export declare function parseVibe(value: string | undefined): Vibe;
+export declare function sanitizeScope(value: string): string;
+export declare class UsageError extends Error {
+    constructor(message: string);
+}
+export declare function helpText(): string;

package/dist/parse-args.js

@@ -0,0 +1,129 @@
+import { COMMIT_TYPES, VIBES, } from "./types.js";
+const HELP = `vibe-commit — stylish conventional commits, offline-first
+
+Usage
+  vibe-commit [options]
+
+Options
+  --commit            Create the commit with the proposed message
+  --dry-run           Print the message only (default)
+  --type <type>       feat | fix | docs | style | refactor | perf | test | build | ci | chore
+  --scope <scope>     Override inferred scope
+  --vibe <style>      playful | pro | terse          (default: pro)
+  --no-ai             Skip AI even if OPENAI_API_KEY is set
+  --json              Print a machine-readable proposal
+  -h, --help          Show help
+  -v, --version       Show version
+
+Env
+  OPENAI_API_KEY      Optional. When set, draft with an OpenAI-compatible API
+  OPENAI_MODEL        Default: gpt-4o-mini
+  OPENAI_BASE_URL     Default: https://api.openai.com/v1
+  VIBE / VIBE_COMMIT_VIBE   Default vibe when --vibe is omitted
+
+Examples
+  git add -p
+  vibe-commit
+  vibe-commit --vibe playful --commit
+  git commit -m "$(vibe-commit --dry-run)"
+`;
+export function defaultVibeFromEnv(env = process.env) {
+    const raw = (env.VIBE_COMMIT_VIBE ?? env.VIBE ?? "pro").trim().toLowerCase();
+    return VIBES.includes(raw) ? raw : "pro";
+}
+export function parseArgs(argv, env = process.env) {
+    const options = {
+        commit: false,
+        dryRun: false,
+        vibe: defaultVibeFromEnv(env),
+        noAi: false,
+        json: false,
+        help: false,
+        version: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            break;
+        if (arg === "-h" || arg === "--help") {
+            options.help = true;
+            continue;
+        }
+        if (arg === "-v" || arg === "--version") {
+            options.version = true;
+            continue;
+        }
+        if (arg === "--commit") {
+            options.commit = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === "--no-ai") {
+            options.noAi = true;
+            continue;
+        }
+        if (arg === "--json") {
+            options.json = true;
+            continue;
+        }
+        if (arg === "--type" || arg.startsWith("--type=")) {
+            const value = arg.includes("=") ? arg.slice("--type=".length) : argv[++i];
+            options.type = parseType(value);
+            continue;
+        }
+        if (arg === "--scope" || arg.startsWith("--scope=")) {
+            const value = arg.includes("=") ? arg.slice("--scope=".length) : argv[++i];
+            if (!value)
+                throw new UsageError("Missing value for --scope");
+            options.scope = sanitizeScope(value);
+            continue;
+        }
+        if (arg === "--vibe" || arg.startsWith("--vibe=")) {
+            const value = arg.includes("=") ? arg.slice("--vibe=".length) : argv[++i];
+            options.vibe = parseVibe(value);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new UsageError(`Unknown option: ${arg}`);
+        }
+        throw new UsageError(`Unexpected argument: ${arg}`);
+    }
+    return options;
+}
+export function parseType(value) {
+    const raw = value?.trim().toLowerCase();
+    if (!raw)
+        throw new UsageError("Missing value for --type");
+    if (!COMMIT_TYPES.includes(raw)) {
+        throw new UsageError(`Invalid --type "${value}". Use: ${COMMIT_TYPES.join(", ")}`);
+    }
+    return raw;
+}
+export function parseVibe(value) {
+    const raw = value?.trim().toLowerCase();
+    if (!raw)
+        throw new UsageError("Missing value for --vibe");
+    if (!VIBES.includes(raw)) {
+        throw new UsageError(`Invalid --vibe "${value}". Use: ${VIBES.join(", ")}`);
+    }
+    return raw;
+}
+export function sanitizeScope(value) {
+    const scope = value.trim().replace(/^[\s(/]+|[\s)/]+$/g, "");
+    if (!scope)
+        throw new UsageError("Scope cannot be empty");
+    return scope;
+}
+export class UsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UsageError";
+    }
+}
+export function helpText() {
+    return HELP;
+}
+//# sourceMappingURL=parse-args.js.map

package/dist/parse-diff.d.ts

@@ -0,0 +1,5 @@
+import type { DiffHunk, StagedDiff, StagedFile } from "./types.ts";
+export declare function parseNameStatus(output: string): Map<string, StagedFile>;
+export declare function applyNumstat(files: Map<string, StagedFile>, output: string): void;
+export declare function parseUnifiedDiff(raw: string): DiffHunk[];
+export declare function assembleDiff(nameStatus: string, numstat: string, raw: string): StagedDiff;

package/dist/parse-diff.js

@@ -0,0 +1,113 @@
+const STATUS_MAP = {
+    A: "A",
+    M: "M",
+    D: "D",
+    R: "R",
+    C: "C",
+    T: "T",
+    U: "U",
+};
+export function parseNameStatus(output) {
+    const files = new Map();
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        const match = line.match(/^([A-Z])(\d*)\t([^\t]+)(?:\t([^\t]+))?$/);
+        if (!match)
+            continue;
+        const code = match[1] ?? "M";
+        const status = STATUS_MAP[code] ?? "M";
+        const first = (match[3] ?? "").trim();
+        const second = match[4]?.trim();
+        if (status === "R" || status === "C") {
+            const path = second || first;
+            files.set(path, {
+                path,
+                fromPath: first,
+                status,
+                additions: 0,
+                deletions: 0,
+            });
+        }
+        else {
+            files.set(first, {
+                path: first,
+                status,
+                additions: 0,
+                deletions: 0,
+            });
+        }
+    }
+    return files;
+}
+export function applyNumstat(files, output) {
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        const match = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+        if (!match)
+            continue;
+        const pathToken = match[3] ?? "";
+        let path = pathToken;
+        let fromPath;
+        const rename = pathToken.match(/^(.+) => (.+)$/);
+        if (rename) {
+            fromPath = stripRenameBrace(rename[1] ?? "");
+            path = stripRenameBrace(rename[2] ?? "");
+        }
+        const existing = files.get(path) ?? {
+            path,
+            fromPath,
+            status: (fromPath ? "R" : "M"),
+            additions: 0,
+            deletions: 0,
+        };
+        existing.additions = match[1] === "-" ? 0 : Number(match[1]);
+        existing.deletions = match[2] === "-" ? 0 : Number(match[2]);
+        if (fromPath && !existing.fromPath)
+            existing.fromPath = fromPath;
+        files.set(path, existing);
+    }
+}
+function stripRenameBrace(value) {
+    return value.replace(/^\{/, "").replace(/\}$/, "");
+}
+export function parseUnifiedDiff(raw) {
+    const hunks = [];
+    let currentPath;
+    let current;
+    for (const line of raw.split("\n")) {
+        const gitHeader = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+        if (gitHeader) {
+            currentPath = gitHeader[2];
+            current = undefined;
+            continue;
+        }
+        const plusPath = line.match(/^\+\+\+ b\/(.+)$/);
+        if (plusPath && plusPath[1] !== "/dev/null") {
+            currentPath = plusPath[1];
+            continue;
+        }
+        if (line.startsWith("@@")) {
+            if (!currentPath)
+                continue;
+            current = { path: currentPath, header: line, lines: [] };
+            hunks.push(current);
+            continue;
+        }
+        if (current && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
+            current.lines.push(line);
+        }
+    }
+    return hunks;
+}
+export function assembleDiff(nameStatus, numstat, raw) {
+    const files = parseNameStatus(nameStatus);
+    applyNumstat(files, numstat);
+    return {
+        files: [...files.values()].sort((a, b) => a.path.localeCompare(b.path)),
+        hunks: parseUnifiedDiff(raw),
+        raw,
+    };
+}
+//# sourceMappingURL=parse-diff.js.map

package/dist/propose.d.ts

@@ -0,0 +1,2 @@
+import type { ProposeOptions, ProposedMessage, StagedDiff } from "./types.ts";
+export declare function proposeMessage(diff: StagedDiff, options: ProposeOptions, env?: NodeJS.ProcessEnv): Promise<ProposedMessage>;

package/dist/propose.js

@@ -0,0 +1,23 @@
+import { proposeWithAi } from "./ai.js";
+import { proposeHeuristic } from "./heuristic.js";
+export async function proposeMessage(diff, options, env = process.env) {
+    const heuristic = proposeHeuristic({
+        diff,
+        type: options.type,
+        scope: options.scope,
+        vibe: options.vibe,
+    });
+    if (options.preferAi === false)
+        return heuristic;
+    const hasKey = Boolean(env.OPENAI_API_KEY?.trim());
+    if (!hasKey)
+        return heuristic;
+    const ai = await proposeWithAi({
+        diff,
+        vibe: options.vibe,
+        type: options.type,
+        scope: options.scope,
+    }, env);
+    return ai ?? heuristic;
+}
+//# sourceMappingURL=propose.js.map

package/dist/render.d.ts

@@ -0,0 +1,7 @@
+import type { ProposedMessage, StagedDiff } from "./types.ts";
+export declare function renderProposal(diff: StagedDiff, message: ProposedMessage, hints?: {
+    committed?: boolean;
+    piped?: boolean;
+}): string;
+export declare function renderError(message: string): string;
+export declare function renderVersion(version: string): string;