@johnowennixon/diffdash 1.1.0 → 1.2.1

package/dist/src/lib_diffdash_sequence.js

@@ -0,0 +1,199 @@
+import { abort_with_error, abort_with_warning } from "./lib_abort.js";
+import { debug_channels, debug_inspect } from "./lib_debug.js";
+import { diffdash_add_footer, diffdash_add_prefix_or_suffix } from "./lib_diffdash_add.js";
+import { error_get_text } from "./lib_error.js";
+import { git_message_display } from "./lib_git_message_display.js";
+import { git_message_generate_result } from "./lib_git_message_generate.js";
+import { git_message_validate_check, git_message_validate_get_result } from "./lib_git_message_validate.js";
+import { git_simple_open_check_not_bare, git_simple_open_git_repo } from "./lib_git_simple_open.js";
+import { git_simple_staging_create_commit, git_simple_staging_get_staged_diff, git_simple_staging_get_staged_diffstat, git_simple_staging_has_staged_changes, git_simple_staging_has_unstaged_changes, git_simple_staging_push_to_remote, git_simple_staging_stage_all_changes, } from "./lib_git_simple_staging.js";
+import { llm_config_get_model_via } from "./lib_llm_config.js";
+import { stdio_write_stdout_linefeed } from "./lib_stdio_write.js";
+import { tell_action, tell_info, tell_plain, tell_success, tell_warning } from "./lib_tell.js";
+import { tui_justify_left } from "./lib_tui_justify.js";
+import { tui_readline_confirm } from "./lib_tui_readline.js";
+async function phase_open() {
+    const git = await git_simple_open_git_repo();
+    await git_simple_open_check_not_bare(git);
+    return git;
+}
+async function phase_add({ config, git }) {
+    const { auto_add, disable_add, silent } = config;
+    if (debug_channels.git) {
+        const status = await git.status();
+        debug_inspect(status, "status");
+    }
+    const has_staged_changes = await git_simple_staging_has_staged_changes(git);
+    if (has_staged_changes) {
+        return;
+    }
+    const has_unstaged_changes = await git_simple_staging_has_unstaged_changes(git);
+    if (!has_unstaged_changes) {
+        abort_with_warning("No changes found in the repository - there is nothing to commit");
+    }
+    if (disable_add) {
+        abort_with_warning("No staged changes found and adding changes is disabled");
+    }
+    if (auto_add) {
+        if (!silent) {
+            tell_action("Auto-adding changes");
+        }
+    }
+    else {
+        const add_confirmed = await tui_readline_confirm("No staged changes found - would you like to add all changes?");
+        if (!add_confirmed) {
+            abort_with_warning("Please add changes before creating a commit");
+        }
+    }
+    await git_simple_staging_stage_all_changes(git);
+    if (!silent) {
+        tell_success("All changed files added successfully");
+    }
+}
+async function phase_status({ config, git }) {
+    const { disable_status, silent } = config;
+    if (disable_status || silent) {
+        return;
+    }
+    tell_info("Files staged for commit:");
+    const status = await git.status();
+    const files_added = status.files.filter((file) => file.index === "A");
+    const files_deleted = status.files.filter((file) => file.index === "D");
+    const files_renamed = status.files.filter((file) => file.index === "R");
+    const files_modified = status.files.filter((file) => file.index === "M");
+    const files_staged = [
+        // All the possible staged index codes
+        ...files_added,
+        ...files_deleted,
+        ...files_renamed,
+        ...files_modified,
+    ];
+    const max_length = Math.max(...files_staged.map((file) => file.path.length), 10);
+    for (const file of files_added) {
+        stdio_write_stdout_linefeed(`  ${tui_justify_left(max_length, file.path)}  (added)`);
+    }
+    for (const file of files_modified) {
+        stdio_write_stdout_linefeed(`  ${tui_justify_left(max_length, file.path)}  (modified)`);
+    }
+    for (const file of files_renamed) {
+        stdio_write_stdout_linefeed(`  ${tui_justify_left(max_length, file.path)}  (renamed from ${file.from})`);
+    }
+    for (const file of files_deleted) {
+        stdio_write_stdout_linefeed(`  ${tui_justify_left(max_length, file.path)}  (deleted)`);
+    }
+    if (files_staged.length === 0) {
+        abort_with_warning("No files staged for commit");
+    }
+}
+async function phase_compare({ config, git }) {
+    const { silent } = config;
+    if (!silent) {
+        tell_action("Generating Git commit messages using all models in parallel");
+    }
+    const { all_llm_configs, add_prefix, add_suffix } = config;
+    const diffstat = await git_simple_staging_get_staged_diffstat(git);
+    const diff = await git_simple_staging_get_staged_diff(git);
+    const inputs = { diffstat, diff };
+    const result_promises = all_llm_configs.map((llm_config) => git_message_generate_result({ llm_config, inputs }));
+    const all_results = await Promise.all(result_promises);
+    for (const result of all_results) {
+        const { llm_config, seconds, error_text } = result;
+        let { git_message } = result;
+        const model_via = llm_config_get_model_via(llm_config);
+        if (error_text) {
+            tell_warning(`Failed to generate a commit message in ${seconds} seconds using ${model_via}: ${error_text}`);
+            continue;
+        }
+        if (!git_message) {
+            continue;
+        }
+        tell_info(`Git commit message in ${seconds} seconds using ${model_via}:`);
+        const validation_result = git_message_validate_get_result(git_message);
+        const teller = validation_result.valid ? tell_plain : tell_warning;
+        git_message = diffdash_add_prefix_or_suffix({ git_message, add_prefix, add_suffix });
+        git_message = diffdash_add_footer({ git_message, llm_config });
+        git_message_display({ git_message, teller });
+    }
+}
+async function phase_commit({ config, git }) {
+    const { add_prefix, add_suffix, auto_commit, disable_commit, disable_preview, silent, llm_config } = config;
+    const model_via = llm_config_get_model_via(llm_config);
+    if (!silent) {
+        tell_action(`Generating the Git commit message using ${model_via}`);
+    }
+    const diffstat = await git_simple_staging_get_staged_diffstat(git);
+    const diff = await git_simple_staging_get_staged_diff(git);
+    const inputs = { diffstat, diff };
+    const result = await git_message_generate_result({ llm_config, inputs });
+    const { error_text } = result;
+    let { git_message } = result;
+    if (error_text) {
+        abort_with_error(`Failed to generate a commit message using ${model_via}: ${error_text}`);
+    }
+    if (!git_message) {
+        return;
+    }
+    git_message_validate_check(git_message);
+    git_message = diffdash_add_prefix_or_suffix({ git_message, add_prefix, add_suffix });
+    git_message = diffdash_add_footer({ git_message, llm_config });
+    if (!disable_preview && !silent) {
+        git_message_display({ git_message, teller: tell_plain });
+    }
+    if (disable_commit) {
+        return;
+    }
+    if (auto_commit) {
+        if (!silent) {
+            tell_action("Auto-committing changes");
+        }
+    }
+    else {
+        const commit_confirmed = await tui_readline_confirm("Do you want to commit these changes?");
+        if (!commit_confirmed) {
+            abort_with_warning("Commit cancelled by user");
+        }
+    }
+    await git_simple_staging_create_commit(git, git_message);
+    if (!silent) {
+        tell_success("Changes committed successfully");
+    }
+}
+async function phase_push({ config, git }) {
+    const { auto_push, disable_commit, disable_push, push_no_verify, push_force, silent } = config;
+    if (disable_push || disable_commit) {
+        return;
+    }
+    if (auto_push) {
+        if (!silent) {
+            tell_action("Auto-pushing changes");
+        }
+    }
+    else {
+        const push_confirmed = await tui_readline_confirm("Do you want to push these changes?");
+        if (!push_confirmed) {
+            return;
+        }
+    }
+    try {
+        await git_simple_staging_push_to_remote({ git, no_verify: push_no_verify, force: push_force });
+    }
+    catch (error) {
+        abort_with_error(`Failed to push to remote: ${error_get_text(error)}`);
+    }
+    if (!silent) {
+        tell_success("Changes pushed successfully");
+    }
+}
+export async function diffdash_sequence_normal(config) {
+    const git = await phase_open();
+    await phase_add({ config, git });
+    await phase_status({ config, git });
+    await phase_commit({ config, git });
+    await phase_push({ config, git });
+}
+export async function diffdash_sequence_compare(config) {
+    const git = await phase_open();
+    await phase_add({ config, git });
+    await phase_status({ config, git });
+    await phase_compare({ config, git });
+}

package/dist/src/lib_duration.js

@@ -0,0 +1,29 @@
+import { abort_with_error } from "./lib_abort.js";
+export class Duration {
+    hrtime_start;
+    hrtime_stop;
+    start() {
+        this.hrtime_start = process.hrtime.bigint();
+    }
+    stop() {
+        this.hrtime_stop = process.hrtime.bigint();
+    }
+    nanoseconds() {
+        if (this.hrtime_start === undefined || this.hrtime_stop === undefined) {
+            abort_with_error("Duration uninitialized");
+        }
+        return Number(this.hrtime_stop - this.hrtime_start);
+    }
+    seconds_complete() {
+        return this.nanoseconds() / 1_000_000_000;
+    }
+    milliseconds_complete() {
+        return this.nanoseconds() / 1_000_000;
+    }
+    seconds_rounded() {
+        return Math.round(this.seconds_complete());
+    }
+    milliseconds_rounded() {
+        return Math.round(this.milliseconds_complete());
+    }
+}

package/dist/src/lib_enabled.js

@@ -0,0 +1,30 @@
+import { DIGIT_0, DIGIT_1 } from "./lib_char_digit.js";
+export function enabled_from_string(value, options) {
+    const fallback = options?.default ?? false;
+    if (value === undefined || value === null) {
+        return fallback;
+    }
+    if (value === DIGIT_0) {
+        return false;
+    }
+    if (value === DIGIT_1) {
+        return true;
+    }
+    const upper = value.toUpperCase();
+    if (upper === "FALSE") {
+        return false;
+    }
+    if (upper === "TRUE") {
+        return true;
+    }
+    if (upper === "DISABLED") {
+        return false;
+    }
+    if (upper === "ENABLED") {
+        return true;
+    }
+    return fallback;
+}
+export function enabled_from_env(key, options) {
+    return enabled_from_string(process.env[key], options);
+}

package/dist/src/lib_env.js

@@ -0,0 +1,18 @@
+import { abort_with_error } from "./lib_abort.js";
+import { EMPTY } from "./lib_char_empty.js";
+export const DOT_ENV = ".env";
+export function env_get(key) {
+    return process.env[key] ?? null;
+}
+export function env_get_substitute(key, substitute) {
+    return env_get(key) ?? substitute;
+}
+export function env_get_empty(key) {
+    return env_get_substitute(key, EMPTY);
+}
+export function env_get_abort(key) {
+    return env_get(key) ?? abort_with_error(`Unable to find environment key: ${key}`);
+}
+export function env_set(key, value) {
+    process.env[key] = value;
+}

package/dist/src/lib_error.js

@@ -0,0 +1,14 @@
+import { abort_with_error } from "./lib_abort.js";
+export function error_ignore(_error) {
+    /* intentionally left empty */
+}
+export function error_console(error) {
+    console.error(error);
+}
+export function error_get_text(error) {
+    return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+export function error_abort(error) {
+    const message = `Unhandled error: ${error_get_text(error)}`;
+    abort_with_error(message);
+}

package/dist/src/lib_file_path.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+export function file_path_delimiter() {
+    return path.delimiter;
+}
+export function file_path_join(segment1, ...segments) {
+    return path.join(segment1, ...segments);
+}
+export function file_path_basename(file_path) {
+    return path.basename(file_path);
+}
+export function file_path_dirname(file_path) {
+    return path.dirname(file_path);
+}
+export function file_path_extname(file_path) {
+    return path.extname(file_path);
+}
+export function file_path_absolute(relative_path) {
+    return path.resolve(relative_path);
+}
+export function file_path_relative({ base_dir, file_path }) {
+    return path.relative(base_dir, file_path);
+}

package/dist/src/lib_git_message_display.js

@@ -0,0 +1,4 @@
+import { tui_block_string } from "./lib_tui_block.js";
+export function git_message_display({ git_message, teller }) {
+    tui_block_string({ teller, content: git_message });
+}

package/dist/src/lib_git_message_generate.js

@@ -0,0 +1,55 @@
+import { Duration } from "./lib_duration.js";
+import { error_get_text } from "./lib_error.js";
+import { git_message_get_system_prompt, git_message_get_user_prompt } from "./lib_git_message_prompt.js";
+import { git_message_schema, git_message_schema_format } from "./lib_git_message_schema.js";
+import { llm_chat_generate_object, llm_chat_generate_text } from "./lib_llm_chat.js";
+import { llm_tokens_count_estimated, llm_tokens_debug_usage } from "./lib_llm_tokens.js";
+async function git_message_generate_unstructured({ llm_config, system_prompt, user_prompt, }) {
+    const llm_response_text = await llm_chat_generate_text({ llm_config, system_prompt, user_prompt });
+    return llm_response_text;
+}
+async function git_message_generate_structured({ llm_config, system_prompt, user_prompt, }) {
+    const schema = git_message_schema;
+    const llm_response_structured = await llm_chat_generate_object({
+        llm_config,
+        system_prompt,
+        user_prompt,
+        schema,
+    });
+    const llm_response_text = git_message_schema_format(llm_response_structured);
+    return llm_response_text;
+}
+export async function git_message_generate_string({ llm_config, inputs, }) {
+    const { context_window, has_structured_json } = llm_config.llm_model_detail;
+    const system_prompt = git_message_get_system_prompt({ has_structured_json });
+    // Estimate remaining prompt length
+    const user_tokens = context_window - llm_tokens_count_estimated({ llm_config, text: system_prompt }) - 1000;
+    const user_length = user_tokens * 3;
+    const user_prompt = git_message_get_user_prompt({
+        has_structured_json,
+        inputs,
+        max_length: user_length,
+    });
+    llm_tokens_debug_usage({ name: "Inputs", llm_config, text: system_prompt + user_prompt });
+    const llm_response_text = has_structured_json
+        ? await git_message_generate_structured({ llm_config, system_prompt, user_prompt })
+        : await git_message_generate_unstructured({ llm_config, system_prompt, user_prompt });
+    llm_tokens_debug_usage({ name: "Outputs", llm_config, text: llm_response_text });
+    return llm_response_text;
+}
+export async function git_message_generate_result({ llm_config, inputs, }) {
+    const duration = new Duration();
+    duration.start();
+    try {
+        const git_message = await git_message_generate_string({ llm_config, inputs });
+        duration.stop();
+        const seconds = duration.seconds_rounded();
+        return { llm_config, seconds, git_message, error_text: null };
+    }
+    catch (error) {
+        duration.stop();
+        const seconds = duration.seconds_rounded();
+        const error_text = error_get_text(error);
+        return { llm_config, seconds, git_message: null, error_text };
+    }
+}

package/dist/src/lib_git_message_prompt.js

@@ -0,0 +1,72 @@
+import { LF } from "./lib_char_control.js";
+import { EMPTY } from "./lib_char_empty.js";
+const portion_role = `
+Your role is to generate a Git commit message in conversational English.
+The user does not want Conventional Commits - the summary line must be a normal sentence.
+`.trim() + LF;
+const portion_inputs = `
+The user will send you a <diffstat> block, the output of a 'git diff --staged --stat' command.
+The user will send you a <diff> block, the output of a 'git diff --staged' command.
+`.trim() + LF;
+const portion_reminders = `
+Some reminders of how diffs work:
+- Lines that start with a single plus sign have been added to the file.
+- Lines that start with a single minus sign have been removed from the file.
+- Lines that start with @@ indicate a jump to a different section of the file - you can not see the code in these gaps.
+`.trim() + LF;
+const portion_format_structured = `
+You must output in the following format (this will be forced):
+- summary_line: a single sentence giving a concise summary of the changes.
+- extra_lines: additional sentences giving more information about the changes.
+`.trim() + LF;
+const portion_format_unstructured = `
+You must output in the following format - without any preamble or conclusion:
+- First line: a single sentence giving a concise summary of the changes.
+- Second line: completely blank - not even any spaces.
+- Then an unordered list (with a dash prefix) of additional sentences giving more information about the changes.
+- And nothing else.
+`.trim() + LF;
+function portion_format(has_structured_json) {
+    return has_structured_json ? portion_format_structured : portion_format_unstructured;
+}
+const portion_instructions = `
+Use the imperative mood and present tense.
+Please write in full sentences that start with a capital letter.
+Write prose rather than making lists.
+Keep each sentence no longer than about twenty words.
+Focus on why things were changed, not how or what.
+Things that are being added are more relevant than things that are being deleted.
+Code changes are more important than documentation changes.
+Be humble - you don't really know why the change was made.
+Don't assume the change is always an improvement - it might be making things worse.
+The number of additional sentences should depend upon the complexity of the change.
+A simple change needs only two additional sentences scaling up to a complex change with five additional sentences.
+If there are a lot of changes, you will need to summarize even more.
+`.trim() + LF;
+const portion_final = `
+Everything you write will be checked for validity and then saved directly to Git - it will not be reviewed by a human.
+Therefore, you must just output the Git message itself without any introductory or concluding sections.
+`.trim() + LF;
+export function git_message_get_system_prompt({ has_structured_json }) {
+    let system_prompt = EMPTY;
+    system_prompt += portion_role + LF;
+    system_prompt += portion_inputs + LF;
+    system_prompt += portion_reminders + LF;
+    system_prompt += portion_format(has_structured_json) + LF;
+    system_prompt += portion_instructions + LF;
+    system_prompt += portion_final + LF;
+    return system_prompt.trim();
+}
+export function git_message_get_user_prompt({ has_structured_json, inputs, max_length, }) {
+    const { diffstat, diff } = inputs;
+    const truncate = diffstat.length + diff.length > max_length;
+    const diff_truncated = truncate ? diff.slice(0, max_length - diffstat.length) + LF : diff;
+    let user_prompt = EMPTY;
+    user_prompt += "<diffstat>" + LF + diffstat + "</diffstat>" + LF + LF;
+    user_prompt += "<diff>" + LF + diff_truncated + "</diff>" + LF + LF;
+    if (truncate) {
+        user_prompt += "Please note: the Diff above has been truncated" + LF + LF;
+    }
+    user_prompt += portion_format(has_structured_json) + LF;
+    return user_prompt.trim();
+}

package/dist/src/lib_git_message_schema.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { LF } from "./lib_char_control.js";
+import { EMPTY } from "./lib_char_empty.js";
+export const git_message_schema = z.object({
+    summary_line: z.string().describe("A single sentence giving a concise summary of the changes."),
+    extra_lines: z
+        .array(z.string().describe("Another sentence giving more information about the changes."))
+        .describe("More information about the changes."),
+});
+export function git_message_schema_format(message) {
+    return [
+        message.summary_line,
+        EMPTY, // Empty line
+        ...message.extra_lines.map((line) => (line.startsWith("- ") ? line : `- ${line}`)),
+    ].join(LF);
+}

package/dist/src/lib_git_message_validate.js

@@ -0,0 +1,61 @@
+import { abort_with_error } from "./lib_abort.js";
+import { LF } from "./lib_char_control.js";
+import { EMPTY } from "./lib_char_empty.js";
+import { ASTERISK, DASH, SPACE } from "./lib_char_punctuation.js";
+import { git_message_display } from "./lib_git_message_display.js";
+import { tell_warning } from "./lib_tell.js";
+const DEFAULT_MIN_LENGTH = 40;
+const DEFAULT_MAX_LENGTH = 4000;
+export function git_message_validate_get_result(git_message) {
+    const min_length = DEFAULT_MIN_LENGTH;
+    const max_length = DEFAULT_MAX_LENGTH;
+    if (!git_message || git_message.trim() === EMPTY) {
+        return {
+            valid: false,
+            reason: "message is empty",
+        };
+    }
+    if (git_message.length < min_length) {
+        return {
+            valid: false,
+            reason: `too short (minimum ${min_length} characters)`,
+        };
+    }
+    if (git_message.length > max_length) {
+        return {
+            valid: false,
+            reason: `too long (maximum ${max_length} characters)`,
+        };
+    }
+    const lines = git_message.trim().split(LF);
+    if (lines.length < 3) {
+        return {
+            valid: false,
+            reason: "need at least 3 lines",
+        };
+    }
+    if (lines[1] && lines[1].trim() !== EMPTY) {
+        return {
+            valid: false,
+            reason: "missing blank line after summary line",
+        };
+    }
+    for (const line of lines.slice(2)) {
+        if (!line.startsWith(DASH + SPACE) && !line.startsWith(ASTERISK + SPACE)) {
+            return {
+                valid: false,
+                reason: "bullet points are malformed",
+            };
+        }
+    }
+    return {
+        valid: true,
+    };
+}
+export function git_message_validate_check(git_message) {
+    const validation_result = git_message_validate_get_result(git_message);
+    if (!validation_result.valid) {
+        git_message_display({ git_message, teller: tell_warning });
+        abort_with_error(`Generated commit message failed validation: ${validation_result.reason}`);
+    }
+}

package/dist/src/lib_git_simple_open.js

@@ -0,0 +1,24 @@
+import { simpleGit } from "simple-git";
+import { abort_with_error } from "./lib_abort.js";
+import { file_path_absolute } from "./lib_file_path.js";
+export async function git_simple_open_git_repo(repo_path = process.cwd()) {
+    const resolved_path = file_path_absolute(repo_path);
+    const git = simpleGit(resolved_path);
+    const is_repo = await git.checkIsRepo();
+    if (!is_repo) {
+        abort_with_error("This directory is not in a git repository");
+    }
+    return git;
+}
+export async function git_simple_open_check_not_bare(git) {
+    const is_bare_repository = await git.raw(["rev-parse", "--is-bare-repository"]);
+    if (is_bare_repository === "true") {
+        abort_with_error("Cannot operate on a bare repository");
+    }
+}
+export async function git_simple_open_check_no_conflicts(git) {
+    const status = await git.status();
+    if (status.conflicted.length > 0) {
+        abort_with_error("Cannot operate on a repository with conflicts");
+    }
+}

package/dist/src/lib_git_simple_staging.js

@@ -0,0 +1,41 @@
+import { SPACE } from "./lib_char_punctuation.js";
+export async function git_simple_staging_has_staged_changes(git) {
+    const status = await git.status();
+    for (const file of status.files) {
+        if ("ADMR".includes(file.index)) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function git_simple_staging_has_unstaged_changes(git) {
+    const status = await git.status();
+    for (const file of status.files) {
+        if (file.working_dir !== SPACE) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function git_simple_staging_stage_all_changes(git) {
+    await git.add(["--all"]);
+}
+export async function git_simple_staging_get_staged_diffstat(git) {
+    return await git.diff(["--cached", "--stat"]);
+}
+export async function git_simple_staging_get_staged_diff(git) {
+    return await git.diff(["--cached"]);
+}
+export async function git_simple_staging_create_commit(git, git_message) {
+    await git.commit(git_message);
+}
+export async function git_simple_staging_push_to_remote({ git, no_verify = false, force = false, }) {
+    const push_args = ["--follow-tags"];
+    if (no_verify) {
+        push_args.push("--no-verify");
+    }
+    if (force) {
+        push_args.push("--force");
+    }
+    await git.push(push_args);
+}

package/dist/src/lib_inspect.js

@@ -0,0 +1,4 @@
+import { inspect } from "node:util";
+export function inspect_obj_to_string(obj) {
+    return inspect(obj, { depth: Number.POSITIVE_INFINITY, colors: true, breakLength: 160 });
+}

package/dist/src/lib_llm_access.js

@@ -0,0 +1,69 @@
+import { abort_with_error } from "./lib_abort.js";
+import { COMMA } from "./lib_char_punctuation.js";
+import { llm_model_find_detail } from "./lib_llm_model.js";
+import { llm_provider_get_api_key, llm_provider_get_api_key_env } from "./lib_llm_provider.js";
+export function llm_access_available({ llm_model_details, llm_model_name, llm_excludes, }) {
+    if (llm_excludes) {
+        const llm_excludes_array = llm_excludes.split(COMMA).map((exclude) => exclude.trim());
+        for (const llm_exclude of llm_excludes_array) {
+            if (llm_model_name.includes(llm_exclude)) {
+                return false;
+            }
+        }
+    }
+    const detail = llm_model_find_detail({ llm_model_details, llm_model_name });
+    const { llm_provider, llm_model_code_direct, llm_model_code_requesty, llm_model_code_openrouter } = detail;
+    if (llm_model_code_direct !== null && llm_provider !== null) {
+        if (llm_provider_get_api_key(llm_provider)) {
+            return true;
+        }
+    }
+    if (llm_model_code_requesty !== null) {
+        if (llm_provider_get_api_key("requesty")) {
+            return true;
+        }
+    }
+    if (llm_model_code_openrouter !== null) {
+        if (llm_provider_get_api_key("openrouter")) {
+            return true;
+        }
+    }
+    return false;
+}
+export function llm_access_get({ llm_model_details, llm_model_name, llm_router, }) {
+    const detail = llm_model_find_detail({ llm_model_details, llm_model_name });
+    const { llm_provider, llm_model_code_direct, llm_model_code_requesty, llm_model_code_openrouter } = detail;
+    if (!llm_router) {
+        if (llm_model_code_direct !== null && llm_provider !== null) {
+            const llm_api_key = llm_provider_get_api_key(llm_provider);
+            if (llm_api_key) {
+                return { llm_model_code: llm_model_code_direct, llm_provider, llm_api_key };
+            }
+        }
+    }
+    if (llm_model_code_requesty !== null) {
+        const llm_api_key = llm_provider_get_api_key("requesty");
+        if (llm_api_key) {
+            return { llm_model_code: llm_model_code_requesty, llm_provider: "requesty", llm_api_key };
+        }
+    }
+    if (llm_model_code_openrouter !== null) {
+        const llm_api_key = llm_provider_get_api_key("openrouter");
+        if (llm_api_key) {
+            return { llm_model_code: llm_model_code_openrouter, llm_provider: "openrouter", llm_api_key };
+        }
+    }
+    if (llm_model_code_direct !== null && llm_provider !== null) {
+        const llm_api_key = llm_provider_get_api_key(llm_provider);
+        if (llm_api_key) {
+            return { llm_model_code: llm_model_code_direct, llm_provider, llm_api_key };
+        }
+    }
+    const env_requesty = llm_provider_get_api_key_env("requesty");
+    const env_openrouter = llm_provider_get_api_key_env("openrouter");
+    if (llm_provider !== null) {
+        const env_provider = llm_provider_get_api_key_env(llm_provider);
+        abort_with_error(`Please set environment variable ${env_requesty}, ${env_openrouter} or ${env_provider}`);
+    }
+    abort_with_error(`Please set environment variable ${env_requesty} or ${env_openrouter}`);
+}