@johnowennixon/diffdash 1.1.0 → 1.3.0

package/README.md

@@ -21,11 +21,26 @@ A command-line tool to generate Git commit messages using AI.
 npm install -g @johnowennixon/diffdash
 ```
 
+## LLM Models
+
+Currently, for this application, the best LLM model by far is **gpt-4.1-mini** from OpenAI.
+It is set as the default model.
+I can only presume they have done a ton of training on diffs.
+
 ## API Keys
 
 DiffDash requires at least one API key for an LLM provider. These must be provided as environment variables.
 
 ```bash
+# For OpenAI (recommended)
+export OPENAI_API_KEY=your-api-key
+
+# For Requesty
+export REQUESTY_API_KEY=your-api-key
+
+# For OpenRouter
+export OPENROUTER_API_KEY=your-api-key
+
 # For Anthropic
 export ANTHROPIC_API_KEY=your-api-key
 
@@ -34,15 +49,6 @@ export DEEPSEEK_API_KEY=your-api-key
 
 # For Google Gemini
 export GEMINI_API_KEY=your-api-key
-
-# For OpenAI
-export OPENAI_API_KEY=your-api-key
-
-# For Requesty
-export REQUESTY_API_KEY=your-api-key
-
-# For OpenRouter
-export OPENROUTER_API_KEY=your-api-key
 ```
 
 ## Usage

package/dist/package.json

@@ -0,0 +1,80 @@
+{
+    "name": "@johnowennixon/diffdash",
+    "version": "1.3.0",
+    "description": "A command-line tool to generate Git commit messages using AI",
+    "license": "0BSD",
+    "author": "John Owen Nixon",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/johnowennixon/diffdash.git"
+    },
+    "engines": {
+        "node": ">=20"
+    },
+    "type": "module",
+    "files": [
+        "dist"
+    ],
+    "bin": {
+        "diffdash": "dist/src/diffdash.js"
+    },
+    "scripts": {
+        "build": "run-s -ls build:clean build:tsc build:shebang build:chmod",
+        "build:chmod": "echo 'Changing bin files to be executable' && chmodx --package",
+        "build:clean": "echo 'Removing dist' && rimraf dist",
+        "build:shebang": "echo 'Fixing the shebangs' && add-shebangs --node --exclude 'dist/**/lib_*.js' 'dist/**/*.js'",
+        "build:tsc": "echo 'Transpiling TypeScript to dist (using tsc)' && tsc --erasableSyntaxOnly --libReplacement false",
+        "fix": "run-s -ls fix:biome fix:markdownlint",
+        "fix:biome": "echo 'Fixing with Biome' && biome check --write",
+        "fix:eslint": "echo 'Fixing with ESLint' && eslint --fix",
+        "fix:markdownlint": "echo 'Fixing with markdownlint' && markdownlint-cli2 '**/*.md' --fix",
+        "fix:oxlint": "echo 'Fixing with oxlint' && oxlint --fix",
+        "lint": "run-s -ls lint:biome lint:oxlint lint:knip lint:markdownlint",
+        "lint:biome": "echo 'Linting with Biome' && biome check",
+        "lint:eslint": "echo 'Linting with ESLint' && eslint",
+        "lint:knip": "echo 'Linting with Knip' && knip",
+        "lint:markdownlint": "echo 'Linting with markdownlint' && markdownlint-cli2 '**/*.md'",
+        "lint:oxlint": "echo 'Linting with oxlint' && oxlint",
+        "lint:tsc": "echo 'Linting with tsc' && tsc --noEmit --erasableSyntaxOnly --libReplacement false",
+        "test": "run-s -ls lint build"
+    },
+    "dependencies": {
+        "@ai-sdk/anthropic": "1.2.12",
+        "@ai-sdk/deepseek": "0.2.14",
+        "@ai-sdk/google": "1.2.21",
+        "@ai-sdk/openai": "1.3.22",
+        "@openrouter/ai-sdk-provider": "0.7.2",
+        "@requesty/ai-sdk": "0.0.9",
+        "ai": "4.3.16",
+        "ansis": "4.1.0",
+        "argparse": "2.0.1",
+        "cli-table3": "0.6.5",
+        "simple-git": "3.28.0",
+        "zod": "3.25.67"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.0.6",
+        "@eslint/eslintrc": "3.3.1",
+        "@eslint/js": "9.30.0",
+        "@johnowennixon/add-shebangs": "1.1.0",
+        "@johnowennixon/chmodx": "2.0.0",
+        "@stylistic/eslint-plugin": "5.1.0",
+        "@types/argparse": "2.0.17",
+        "@types/node": "24.0.8",
+        "@typescript-eslint/eslint-plugin": "8.35.1",
+        "@typescript-eslint/parser": "8.35.1",
+        "eslint": "9.30.0",
+        "eslint-import-resolver-typescript": "4.4.4",
+        "eslint-plugin-import-x": "4.16.1",
+        "eslint-plugin-sonarjs": "3.0.4",
+        "eslint-plugin-unicorn": "59.0.1",
+        "globals": "16.3.0",
+        "knip": "5.61.3",
+        "markdownlint-cli2": "0.18.1",
+        "npm-run-all2": "8.0.4",
+        "oxlint": "1.4.0",
+        "rimraf": "6.0.1",
+        "typescript": "5.8.3",
+        "typescript-eslint": "8.35.1"
+    }
+}

package/dist/src/diffdash.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { ansi_blue, ansi_italic, ansi_red } from "./lib_ansi.js";
+import { diffdash_config_get } from "./lib_diffdash_config.js";
+import { diffdash_sequence_compare, diffdash_sequence_normal } from "./lib_diffdash_sequence.js";
+import { error_abort } from "./lib_error.js";
+import { tell_okay, tell_plain } from "./lib_tell.js";
+async function main() {
+    const config = diffdash_config_get();
+    const { llm_compare, silent } = config;
+    if (!silent) {
+        const diffdash = ansi_italic(ansi_blue("Diff") + ansi_red("Dash"));
+        tell_plain(`This is ${diffdash} - the fast AI Git commit tool`);
+    }
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (llm_compare) {
+        await diffdash_sequence_compare(config);
+    }
+    else {
+        await diffdash_sequence_normal(config);
+    }
+    if (!silent) {
+        tell_okay();
+    }
+}
+// eslint-disable-next-line unicorn/prefer-top-level-await
+main().catch(error_abort);

package/dist/src/lib_abort.js

@@ -0,0 +1,21 @@
+import { ansi_red, ansi_yellow } from "./lib_ansi.js";
+import { stdio_write_stderr_linefeed } from "./lib_stdio_write.js";
+export function abort_exit() {
+    process.exit(1);
+}
+export function abort_with_warning(message) {
+    if (process.stdout.isTTY) {
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+    }
+    stdio_write_stderr_linefeed(ansi_yellow(message));
+    abort_exit();
+}
+export function abort_with_error(message) {
+    if (process.stdout.isTTY) {
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+    }
+    stdio_write_stderr_linefeed(ansi_red(message));
+    abort_exit();
+}

package/dist/src/lib_ansi.js

@@ -0,0 +1,21 @@
+import ansis from "ansis";
+import { EMPTY } from "./lib_char_empty.js";
+export const ansi_normal = (message) => message;
+export const ansi_dim = (message) => ansis.dim(message);
+export const ansi_bold = (message) => ansis.bold(message);
+export const ansi_italic = (message) => ansis.italic(message);
+export const ansi_red = (message) => ansis.redBright(message);
+export const ansi_yellow = (message) => ansis.yellowBright(message);
+export const ansi_green = (message) => ansis.greenBright(message);
+export const ansi_cyan = (message) => ansis.cyanBright(message);
+export const ansi_blue = (message) => ansis.blueBright(message);
+export const ansi_magenta = (message) => ansis.magentaBright(message);
+export const ansi_grey = (message) => ansis.gray(message);
+export function ansi_boolean(bool) {
+    return bool ? ansi_green : ansi_red;
+}
+export function ansi_strip(text) {
+    const pattern = String.raw `\u001B\[[^m]*m`;
+    // eslint-disable-next-line sonarjs/no-control-regex
+    return text.replace(new RegExp(pattern, "g"), EMPTY);
+}

package/dist/src/lib_char_box.js

@@ -0,0 +1,3 @@
+export const BOX_DRAWINGS_DOUBLE_HORIZONTAL = "\u2550";
+export const BOX_DRAWINGS_HEAVY_HORIZONTAL = "\u2501";
+export const BOX_DRAWINGS_LIGHT_HORIZONTAL = "\u2500";

package/dist/src/lib_char_control.js

@@ -0,0 +1,8 @@
+export const BS = "\b";
+export const CR = "\r";
+export const ESC = "\u001B";
+export const FF = "\f";
+export const LF = "\n";
+export const NUL = "\0";
+export const TAB = "\t";
+export const VT = "\v";

package/dist/src/lib_char_digit.js

@@ -0,0 +1,10 @@
+export const DIGIT_0 = "0";
+export const DIGIT_1 = "1";
+export const DIGIT_2 = "2";
+export const DIGIT_3 = "3";
+export const DIGIT_4 = "4";
+export const DIGIT_5 = "5";
+export const DIGIT_6 = "6";
+export const DIGIT_7 = "7";
+export const DIGIT_8 = "8";
+export const DIGIT_9 = "9";

package/dist/src/lib_char_empty.js

@@ -0,0 +1 @@
+export const EMPTY = "";

package/dist/src/lib_char_punctuation.js

@@ -0,0 +1,37 @@
+export const AMPERSAND = "&";
+export const APOSTROPHE = "'";
+export const ASTERISK = "*";
+export const AT_SIGN = "@";
+export const BACKSLASH = "\\";
+export const BACKTICK = "`";
+export const CARET = "^";
+export const COLON = ":";
+export const COMMA = ",";
+export const CURLY_LEFT = "{";
+export const CURLY_RIGHT = "}";
+export const DASH = "-";
+export const DOLLAR = "$";
+export const DOT = ".";
+export const ELLIPSIS = "…";
+export const EQUALS = "=";
+export const HASH = "#";
+export const HAT = "^";
+export const LESS_THAN = "<";
+export const MORE_THAN = ">";
+export const MINUS = "-";
+export const PERCENT = "%";
+export const PIPE = "|";
+export const PLUS = "+";
+export const POUND_SIGN = "£";
+export const QUESTION = "?";
+export const QUOTE_DOUBLE = '"';
+export const QUOTE_SINGLE = "'";
+export const ROUND_LEFT = "(";
+export const ROUND_RIGHT = ")";
+export const SEMICOLON = ";";
+export const SLASH = "/";
+export const SPACE = " ";
+export const SQUARE_LEFT = "[";
+export const SQUARE_RIGHT = "]";
+export const TILDE = "~";
+export const UNDERSCORE = "_";

package/dist/src/lib_cli.js

@@ -0,0 +1,187 @@
+import { ArgumentParser } from "argparse";
+import { EMPTY } from "./lib_char_empty.js";
+import { DASH, PLUS, UNDERSCORE } from "./lib_char_punctuation.js";
+import { debug_channels, debug_inspect_when } from "./lib_debug.js";
+export function cli_string(options = {}) {
+    return { kind: "string", options, value: "" };
+}
+export function cli_string_always(options = {}) {
+    return { kind: "string", options, value: "" };
+}
+export function cli_integer(options = {}) {
+    return { kind: "integer", options, value: 0 };
+}
+export function cli_integer_always(options = {}) {
+    return { kind: "integer", options, value: 0 };
+}
+export function cli_boolean(options = {}) {
+    return { kind: "boolean", options, value: false };
+}
+export function cli_command_sync(command_sync, options = {}) {
+    return { kind: "boolean", options, value: false, command_sync };
+}
+export function cli_command_async(command_async, options = {}) {
+    return { kind: "boolean", options, value: false, command_async };
+}
+export function cli_choice_optional(options = {}) {
+    return { kind: "choice", options, value: undefined };
+}
+export function cli_choice_default(options = {}) {
+    return { kind: "choice", options, value: undefined };
+}
+export function cli_choice_required(options = {}) {
+    options.required = true;
+    return { kind: "choice", options, value: undefined };
+}
+export function cli_list(options = {}) {
+    return { kind: "list", options, value: [] };
+}
+export function cli_meg_optional(meg_schema) {
+    return { kind: "meg", options: { required: false }, value: meg_schema };
+}
+export function cli_meg_required(meg_schema) {
+    return { kind: "meg", options: { required: true }, value: meg_schema };
+}
+export function cli_meg_required_predicate(meg_schema, predicate) {
+    return { kind: "meg", options: { required: true, predicate }, value: meg_schema };
+}
+function cli_omit(obj, key_to_omit) {
+    const { [key_to_omit]: _, ...rest } = obj;
+    return rest;
+}
+function cli_add_keys({ cli_schema, parser_group, predicate, }) {
+    for (const key in cli_schema) {
+        if (!Object.hasOwn(cli_schema, key)) {
+            continue;
+        }
+        const cli = cli_schema[key];
+        if (!cli) {
+            continue;
+        }
+        if (predicate !== undefined) {
+            if (!predicate(key)) {
+                continue;
+            }
+        }
+        const key_replaced = key.replaceAll(UNDERSCORE, DASH);
+        const key_amended = `${cli.options.positional === true ? EMPTY : "--"}${key_replaced}`;
+        const options = cli_omit(cli.options, "positional");
+        switch (cli.kind) {
+            case "string":
+            case "choice":
+                parser_group.add_argument(key_amended, { ...options });
+                break;
+            case "integer":
+                parser_group.add_argument(key_amended, { ...options, type: "int" });
+                break;
+            case "boolean":
+                parser_group.add_argument(key_amended, { ...options, action: "store_true" });
+                break;
+            case "list":
+                parser_group.add_argument(key_amended, { ...options, nargs: PLUS });
+                break;
+            case "meg":
+                {
+                    const mutually_exclusive_group = parser_group.add_mutually_exclusive_group({
+                        required: cli.options.required === true,
+                    });
+                    cli_add_keys({
+                        cli_schema: cli.value,
+                        parser_group: mutually_exclusive_group,
+                        predicate: cli.options.predicate,
+                    });
+                }
+                break;
+            default:
+                throw new Error("Unknown argument kind");
+        }
+    }
+}
+function cli_recursive_parse({ schema, namespace, predicate, }) {
+    const result = {};
+    for (const key in schema) {
+        if (!Object.hasOwn(schema, key)) {
+            continue;
+        }
+        const cli = schema[key];
+        if (!cli) {
+            continue;
+        }
+        if (predicate !== undefined) {
+            if (!predicate(key)) {
+                continue;
+            }
+        }
+        if (cli.kind === "meg") {
+            const nested_schema = cli.value;
+            result[key] = cli_recursive_parse({
+                schema: nested_schema,
+                namespace,
+                predicate: cli.options.predicate,
+            });
+        }
+        else {
+            result[key] = namespace[key];
+        }
+    }
+    return result;
+}
+function cli_recursive_despatch_sync({ schema, namespace, parsed_args, }) {
+    for (const key in schema) {
+        if (!Object.hasOwn(schema, key)) {
+            continue;
+        }
+        const cli = schema[key];
+        if (!cli) {
+            continue;
+        }
+        if (cli.kind === "meg") {
+            const nested_schema = cli.value;
+            cli_recursive_despatch_sync({ schema: nested_schema, namespace, parsed_args });
+        }
+        else if (cli.kind === "boolean") {
+            if (namespace[key]) {
+                if (cli.command_sync) {
+                    cli.command_sync(parsed_args);
+                }
+            }
+        }
+    }
+}
+async function cli_recursive_despatch_async({ schema, namespace, parsed_args, }) {
+    for (const key in schema) {
+        if (!Object.hasOwn(schema, key)) {
+            continue;
+        }
+        const cli = schema[key];
+        if (!cli) {
+            continue;
+        }
+        if (cli.kind === "meg") {
+            const nested_schema = cli.value;
+            await cli_recursive_despatch_async({ schema: nested_schema, namespace, parsed_args });
+        }
+        else if (cli.kind === "boolean") {
+            if (namespace[key]) {
+                if (cli.command_async) {
+                    await cli.command_async(parsed_args);
+                }
+            }
+        }
+    }
+}
+export function cli_make_parser({ cli_schema, description, }) {
+    const argument_parser_options = { description, allow_abbrev: false };
+    const parser = new ArgumentParser(argument_parser_options);
+    cli_add_keys({ cli_schema, parser_group: parser });
+    const namespace = parser.parse_args();
+    debug_inspect_when(debug_channels.cli, namespace, "namespace");
+    const parsed_args = cli_recursive_parse({ schema: cli_schema, namespace });
+    function despatch_sync() {
+        cli_recursive_despatch_sync({ schema: cli_schema, namespace, parsed_args });
+    }
+    async function despatch_async() {
+        await cli_recursive_despatch_async({ schema: cli_schema, namespace, parsed_args });
+    }
+    return { parsed_args, despatch_sync, despatch_async };
+}

package/dist/src/lib_datetime.js

@@ -0,0 +1,62 @@
+import { EMPTY } from "./lib_char_empty.js";
+import { COLON, DASH, SPACE } from "./lib_char_punctuation.js";
+export function datetime_now() {
+    return new Date();
+}
+export function datetime_now_minus_days(days) {
+    const date = datetime_now();
+    date.setDate(date.getDate() - days);
+    return date;
+}
+export function datetime_parse(s) {
+    return new Date(s);
+}
+export function datetime_parse_timestamp(timestamp) {
+    const year = Number.parseInt(timestamp.slice(0, 4), 10);
+    const month_index = Number.parseInt(timestamp.slice(4, 6), 10) - 1;
+    const day = Number.parseInt(timestamp.slice(6, 8), 10);
+    const hours = Number.parseInt(timestamp.slice(8, 10), 10);
+    const minutes = Number.parseInt(timestamp.slice(10, 12), 10);
+    const seconds = Number.parseInt(timestamp.slice(12, 14), 10);
+    const utc = Date.UTC(year, month_index, day, hours, minutes, seconds);
+    const date = new Date(utc);
+    return date;
+}
+export function datetime_format_utc_iso_ymdthms(date) {
+    return date.toISOString().slice(0, 19);
+}
+export function datetime_format_utc_iso_ymd(date) {
+    return date.toISOString().slice(0, 10);
+}
+export function datetime_format_utc_iso_hms(date) {
+    return date.toISOString().slice(11, 19);
+}
+export function datetime_format_utc_timestamp_alpha(date) {
+    const s1 = date.toISOString().slice(0, 19);
+    const s2 = s1.replaceAll(DASH, EMPTY);
+    const s3 = s2.replaceAll(COLON, EMPTY);
+    const s4 = s3 + "Z";
+    return s4;
+}
+export function datetime_format_utc_timestamp_numeric(date) {
+    const s1 = date.toISOString().slice(0, 19);
+    const s2 = s1.replaceAll(DASH, EMPTY);
+    const s3 = s2.replaceAll(COLON, EMPTY);
+    const s4 = s3.replace("T", EMPTY);
+    return s4;
+}
+function datetime_localize(date) {
+    return new Date(date.valueOf() - date.getTimezoneOffset() * 60_000);
+}
+export function datetime_format_local_iso_ymdthms(date) {
+    return datetime_format_utc_iso_ymdthms(datetime_localize(date));
+}
+export function datetime_format_local_iso_ymd_hms(date) {
+    return datetime_format_utc_iso_ymdthms(datetime_localize(date)).replace("T", SPACE);
+}
+export function datetime_format_local_iso_ymd(date) {
+    return datetime_format_utc_iso_ymd(datetime_localize(date));
+}
+export function datetime_format_local_iso_hms(date) {
+    return datetime_format_utc_iso_hms(datetime_localize(date));
+}

package/dist/src/lib_debug.js

@@ -0,0 +1,68 @@
+import { ansi_grey } from "./lib_ansi.js";
+import { EMPTY } from "./lib_char_empty.js";
+import { enabled_from_env } from "./lib_enabled.js";
+import { inspect_obj_to_string } from "./lib_inspect.js";
+import { stdio_write_stderr_linefeed } from "./lib_stdio_write.js";
+import { tell_debug } from "./lib_tell.js";
+export const debug_channels = {
+    api: false,
+    backups: false,
+    child_input: false,
+    child_output: false,
+    cleanup: false,
+    cli: false,
+    cloudflare: false,
+    config: false,
+    data: false,
+    detail: false,
+    forwarding: false,
+    gcp: false,
+    git: false,
+    helm: false,
+    lines: false,
+    llm_inputs: false,
+    llm_outputs: false,
+    llm_tokens: false,
+    llm_tools: false,
+    node: false,
+    path: false,
+    kubectl: false,
+    postgresql: false,
+    rejects: false,
+    retries: false,
+    sql: false,
+};
+export function debug_enable_if(channel, enabled) {
+    if (enabled && !debug_channels[channel]) {
+        debug_channels[channel] = true;
+        tell_debug(`Debugging enabled for ‘${channel}’`);
+    }
+}
+function debug_init() {
+    for (const channel in debug_channels) {
+        if (enabled_from_env(`lib_debug_${channel}`)) {
+            debug_enable_if(channel, true);
+        }
+    }
+}
+debug_init();
+export function debug_tell_when(when, message) {
+    if (when !== undefined && when) {
+        tell_debug(message);
+    }
+}
+export function debug_inspect(obj, name = null) {
+    const prefix = name ? `${name}: ` : EMPTY;
+    const message = prefix + inspect_obj_to_string(obj);
+    stdio_write_stderr_linefeed(ansi_grey(message));
+}
+export function debug_inspect_if(obj, name = null) {
+    if (obj !== undefined) {
+        debug_inspect(obj, name);
+    }
+}
+export function debug_inspect_when(when, obj, name = null) {
+    if (when !== undefined && when) {
+        debug_inspect(obj, name);
+    }
+}

package/dist/src/lib_diffdash_add.js

@@ -0,0 +1,23 @@
+import { LF } from "./lib_char_control.js";
+import { EMPTY } from "./lib_char_empty.js";
+import { datetime_format_local_iso_ymd_hms } from "./lib_datetime.js";
+import { PACKAGE_NAME, PACKAGE_VERSION } from "./lib_package.js";
+export function diffdash_add_prefix_or_suffix({ git_message, add_prefix, add_suffix, }) {
+    if (!add_prefix && !add_suffix) {
+        return git_message;
+    }
+    const lines = git_message.split(LF);
+    if (lines.length === 0) {
+        return git_message;
+    }
+    const formatted_prefix = add_prefix ? `${add_prefix} ` : EMPTY;
+    const formatted_suffix = add_suffix ? ` ${add_suffix}` : EMPTY;
+    lines[0] = `${formatted_prefix}${lines[0]}${formatted_suffix}`;
+    return lines.join(LF);
+}
+export function diffdash_add_footer({ git_message, llm_config }) {
+    const { llm_model_name } = llm_config;
+    const timestamp = datetime_format_local_iso_ymd_hms(new Date());
+    const footer = `Generated by: ${PACKAGE_NAME} v${PACKAGE_VERSION} at ${timestamp} using ${llm_model_name}`;
+    return git_message.trim() + LF + LF + footer;
+}

package/dist/src/lib_diffdash_cli.js

@@ -0,0 +1,34 @@
+import { cli_boolean, cli_choice_default, cli_make_parser, cli_string } from "./lib_cli.js";
+import { diffdash_llm_model_choices, diffdash_llm_model_default, diffdash_llm_model_fallback, } from "./lib_diffdash_llm.js";
+const diffdash_cli_schema = {
+    version: cli_boolean({ help: "show program version information and exit" }),
+    add_prefix: cli_string({ help: "add a prefix to the commit message summary line", metavar: "PREFIX" }),
+    add_suffix: cli_string({ help: "add a suffix to the commit message summary line", metavar: "SUFFIX" }),
+    auto_add: cli_boolean({ help: "automatically stage all changes without confirmation" }),
+    auto_commit: cli_boolean({ help: "automatically commit changes without confirmation" }),
+    auto_push: cli_boolean({ help: "automatically push changes after commit without confirmation" }),
+    disable_add: cli_boolean({ help: "disable adding unstaged changes - exit if no changes staged" }),
+    disable_status: cli_boolean({ help: "disable listing the staged files before generating a message" }),
+    disable_preview: cli_boolean({ help: "disable previewing the generated message" }),
+    disable_commit: cli_boolean({ help: "disable committing changes - exit after generating the message" }),
+    disable_push: cli_boolean({ help: "disable pushing changes - exit after making the commit" }),
+    push_no_verify: cli_boolean({ help: "bypass git hooks when pushing to Git" }),
+    push_force: cli_boolean({ help: "apply force when pushing to Git" }),
+    llm_list: cli_boolean({ help: "display a list of available Large Language Models and exit" }),
+    llm_compare: cli_boolean({ help: "compare the generated messages from all models - but do not commit" }),
+    llm_router: cli_boolean({ help: "prefer to access the LLM via a router rather than direct" }),
+    llm_fallback: cli_boolean({ help: `use the fallback model (${diffdash_llm_model_fallback})` }),
+    llm_model: cli_choice_default({
+        help: `choose the Large Language Model by name (defaults to ${diffdash_llm_model_default})`,
+        choices: diffdash_llm_model_choices,
+        default: diffdash_llm_model_default,
+    }),
+    llm_excludes: cli_string({ help: "models to exclude from comparison (comma separated)", metavar: "MODELS" }),
+    silent: cli_boolean({ help: "suppress all normal output - errors and aborts still display" }),
+    debug_llm_inputs: cli_boolean({ help: "debug inputs (including all prompts) sent to the LLM" }),
+    debug_llm_outputs: cli_boolean({ help: "debug outputs received from the LLM" }),
+};
+export const diffdash_cli_parser = cli_make_parser({
+    cli_schema: diffdash_cli_schema,
+    description: "DiffDash - generate Git commit messages using AI",
+});