@ryanatkn/gro 0.112.0

package/dist/gen.task.js

@@ -0,0 +1,103 @@
+import { red, green, gray } from 'kleur/colors';
+import { print_ms, print_error } from '@ryanatkn/belt/print.js';
+import { plural } from '@ryanatkn/belt/string.js';
+import { z } from 'zod';
+import { dirname } from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { Task_Error } from './task.js';
+import { run_gen } from './run_gen.js';
+import { load_gen_module, check_gen_modules, find_gen_modules } from './gen_module.js';
+import { resolve_input_paths } from './input_path.js';
+import { load_modules } from './modules.js';
+import { format_file } from './format_file.js';
+import { print_path } from './paths.js';
+import { log_error_reasons } from './print_task.js';
+export const Args = z
+    .object({
+    _: z.array(z.string(), { description: 'paths to generate' }).default([]),
+    check: z
+        .boolean({ description: 'exit with a nonzero code if any files need to be generated' })
+        .default(false),
+})
+    .strict();
+// TODO test - especially making sure nothing gets genned
+// if there's any validation or import errors
+export const task = {
+    summary: 'run code generation scripts',
+    Args,
+    run: async ({ args, log, timings }) => {
+        const { _: raw_input_paths, check } = args;
+        // resolve the input paths relative to src/lib/
+        const input_paths = resolve_input_paths(raw_input_paths);
+        // load all of the gen modules
+        const find_modules_result = await find_gen_modules(input_paths);
+        if (!find_modules_result.ok) {
+            if (find_modules_result.type === 'input_directories_with_no_files') {
+                log.info('no gen modules found');
+                return;
+            }
+            else {
+                log_error_reasons(log, find_modules_result.reasons);
+                throw new Task_Error('Failed to find gen modules.');
+            }
+        }
+        log.info('gen files', Array.from(find_modules_result.source_ids_by_input_path.values()).flat());
+        const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, load_gen_module);
+        if (!load_modules_result.ok) {
+            log_error_reasons(log, load_modules_result.reasons);
+            throw new Task_Error('Failed to load gen modules.');
+        }
+        // run `gen` on each of the modules
+        const timing_to_generate_code = timings.start('generate code'); // TODO this ignores `gen_results.elapsed` - should it return `Timings` instead?
+        const gen_results = await run_gen(load_modules_result.modules, log, timings, format_file);
+        timing_to_generate_code();
+        const fail_count = gen_results.failures.length;
+        if (check) {
+            // check if any files changed, and if so, throw errors,
+            // but if there are gen failures, skip the check and defer to their errors
+            if (!fail_count) {
+                log.info('checking generated files for changes');
+                const timing_to_check_results = timings.start('check results for changes');
+                const check_gen_modules_results = await check_gen_modules(gen_results);
+                timing_to_check_results();
+                let has_unexpected_changes = false;
+                for (const result of check_gen_modules_results) {
+                    if (!result.has_changed)
+                        continue;
+                    has_unexpected_changes = true;
+                    log.error(red(`Generated file ${print_path(result.file.id)} via ${print_path(result.file.origin_id)} ${result.is_new ? 'is new' : 'has changed'}.`));
+                }
+                if (has_unexpected_changes) {
+                    throw new Task_Error('Failed gen check. Some generated files have unexpectedly changed.' +
+                        ' Run `gro gen` and try again.');
+                }
+                log.info('check passed, no files have changed');
+            }
+        }
+        else {
+            // write generated files to disk
+            log.info('writing generated files to disk');
+            const timing_to_output_results = timings.start('output results');
+            await Promise.all(gen_results.successes
+                .map((result) => result.files.map(async (file) => {
+                log.info('writing', print_path(file.id), 'generated from', print_path(file.origin_id));
+                await mkdir(dirname(file.id), { recursive: true });
+                await writeFile(file.id, file.content);
+            }))
+                .flat());
+            timing_to_output_results();
+        }
+        let logResult = '';
+        for (const result of gen_results.results) {
+            logResult += `\n\t${result.ok ? green('✓') : red('🞩')}  ${result.ok ? result.files.length : 0} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
+        }
+        log.info(logResult);
+        log.info(green(`generated ${gen_results.output_count} file${plural(gen_results.output_count)} from ${gen_results.successes.length} input file${plural(gen_results.successes.length)}`));
+        if (fail_count) {
+            for (const result of gen_results.failures) {
+                log.error(result.reason, '\n', print_error(result.error));
+            }
+            throw new Task_Error(`Failed to generate ${fail_count} file${plural(fail_count)}.`);
+        }
+    },
+};

package/dist/gen.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gen.test.js

@@ -0,0 +1,239 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { resolve } from 'node:path';
+import { to_gen_result } from './gen.js';
+const origin_id = resolve('src/foo.gen.ts');
+/* test__to_gen_result */
+const test__to_gen_result = suite('to_gen_result');
+test__to_gen_result('plain string', () => {
+    assert.equal(to_gen_result(origin_id, '/**/'), {
+        origin_id,
+        files: [{ id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true }],
+    });
+});
+test__to_gen_result('object with a content string', () => {
+    assert.equal(to_gen_result(origin_id, { content: '/**/' }), {
+        origin_id,
+        files: [{ id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true }],
+    });
+});
+test__to_gen_result('fail with an unresolved id', () => {
+    assert.throws(() => to_gen_result('src/foo.ts', { content: '/**/' }));
+});
+test__to_gen_result('fail with a build id', () => {
+    assert.throws(() => to_gen_result(resolve('.gro/foo.js'), { content: '/**/' }));
+});
+test__to_gen_result('fail with an empty id', () => {
+    assert.throws(() => to_gen_result('', { content: '/**/' }));
+});
+test__to_gen_result('custom file name', () => {
+    assert.equal(to_gen_result(origin_id, {
+        filename: 'fooz.ts',
+        content: '/**/',
+    }), {
+        origin_id,
+        files: [{ id: resolve('src/fooz.ts'), content: '/**/', origin_id, format: true }],
+    });
+});
+test__to_gen_result('custom file name that matches the default file name', () => {
+    assert.equal(to_gen_result(origin_id, {
+        filename: 'foo.ts',
+        content: '/**/',
+    }), {
+        origin_id,
+        files: [{ id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true }],
+    });
+});
+test__to_gen_result('fail when custom file name explicitly matches the origin', () => {
+    assert.throws(() => {
+        to_gen_result(origin_id, {
+            filename: 'foo.gen.ts',
+            content: '/**/',
+        });
+    });
+});
+test__to_gen_result('fail when file name implicitly matches the origin', () => {
+    assert.throws(() => {
+        to_gen_result(resolve('src/foo.ts'), { content: '/**/' });
+    });
+});
+test__to_gen_result('fail with an empty file name', () => {
+    assert.throws(() => to_gen_result(origin_id, { filename: '', content: '/**/' }));
+});
+test__to_gen_result('additional file name parts', () => {
+    assert.equal(to_gen_result(resolve('src/foo.bar.gen.ts'), { content: '/**/' }), {
+        origin_id: resolve('src/foo.bar.gen.ts'),
+        files: [
+            {
+                id: resolve('src/foo.bar.ts'),
+                content: '/**/',
+                origin_id: resolve('src/foo.bar.gen.ts'),
+                format: true,
+            },
+        ],
+    });
+});
+test__to_gen_result('js', () => {
+    assert.equal(to_gen_result(origin_id, {
+        filename: 'foo.js',
+        content: '/**/',
+    }), {
+        origin_id,
+        files: [{ id: resolve('src/foo.js'), content: '/**/', origin_id, format: true }],
+    });
+});
+test__to_gen_result('implicit custom file extension', () => {
+    assert.equal(to_gen_result(resolve('src/foo.gen.json.ts'), '[/**/]'), {
+        origin_id: resolve('src/foo.gen.json.ts'),
+        files: [
+            {
+                id: resolve('src/foo.json'),
+                content: '[/**/]',
+                origin_id: resolve('src/foo.gen.json.ts'),
+                format: true,
+            },
+        ],
+    });
+});
+test__to_gen_result('implicit empty file extension', () => {
+    assert.equal(to_gen_result(resolve('src/foo.gen..ts'), '[/**/]'), {
+        origin_id: resolve('src/foo.gen..ts'),
+        files: [
+            {
+                id: resolve('src/foo'),
+                content: '[/**/]',
+                origin_id: resolve('src/foo.gen..ts'),
+                format: true,
+            },
+        ],
+    });
+});
+test__to_gen_result('implicit custom file extension with additional file name parts', () => {
+    assert.equal(to_gen_result(resolve('src/foo.bar.gen.json.ts'), { content: '[/**/]' }), {
+        origin_id: resolve('src/foo.bar.gen.json.ts'),
+        files: [
+            {
+                id: resolve('src/foo.bar.json'),
+                content: '[/**/]',
+                origin_id: resolve('src/foo.bar.gen.json.ts'),
+                format: true,
+            },
+        ],
+    });
+});
+test__to_gen_result('implicit custom file extension with many dots in between', () => {
+    assert.equal(to_gen_result(resolve('src/foo...gen.ts'), '[/**/]'), {
+        origin_id: resolve('src/foo...gen.ts'),
+        files: [
+            {
+                id: resolve('src/foo...ts'),
+                content: '[/**/]',
+                origin_id: resolve('src/foo...gen.ts'),
+                format: true,
+            },
+        ],
+    });
+});
+test__to_gen_result('fail with two parts following the .gen. pattern in the file name', () => {
+    // This just ensures consistent file names - maybe loosen the restriction?
+    // You can still implicitly name files like this,
+    // but you have to move ".bar" before ".gen".
+    assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.json.ts'), '/**/'));
+});
+test__to_gen_result('fail implicit file extension ending with a dot', () => {
+    // This just ensures consistent file names - maybe loosen the restriction?
+    // This one is more restrictive than the above,
+    // because to have a file ending with a dot
+    // you have to use an explicit file name.
+    assert.throws(() => to_gen_result(resolve('src/foo.gen...ts'), '[/**/]'));
+});
+test__to_gen_result('fail without a .gen. pattern in the file name', () => {
+    assert.throws(() => {
+        to_gen_result(resolve('src/foo.ts'), '/**/');
+    });
+});
+test__to_gen_result('fail without a .gen. pattern in a file name that has multiple other patterns', () => {
+    assert.throws(() => {
+        to_gen_result(resolve('src/foo.bar.baz.ts'), '/**/');
+    });
+});
+test__to_gen_result('fail with two .gen. patterns in the file name', () => {
+    assert.throws(() => to_gen_result(resolve('src/lib/gen.gen.ts'), '/**/'));
+    assert.throws(() => to_gen_result(resolve('src/foo.gen.gen.ts'), '/**/'));
+    assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.gen.ts'), '/**/'));
+    assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.gen.baz.ts'), '/**/'));
+});
+test__to_gen_result('explicit custom file extension', () => {
+    assert.equal(to_gen_result(origin_id, {
+        filename: 'foo.json',
+        content: '[/**/]',
+    }), {
+        origin_id,
+        files: [{ id: resolve('src/foo.json'), content: '[/**/]', origin_id, format: true }],
+    });
+});
+test__to_gen_result('explicit custom empty file extension', () => {
+    assert.equal(to_gen_result(origin_id, {
+        filename: 'foo',
+        content: '[/**/]',
+    }), {
+        origin_id,
+        files: [{ id: resolve('src/foo'), content: '[/**/]', origin_id, format: true }],
+    });
+});
+test__to_gen_result('explicit custom file extension ending with a dot', () => {
+    assert.equal(to_gen_result(origin_id, {
+        filename: 'foo.',
+        content: '[/**/]',
+    }), {
+        origin_id,
+        files: [{ id: resolve('src/foo.'), content: '[/**/]', origin_id, format: true }],
+    });
+});
+test__to_gen_result('simple array of raw files', () => {
+    assert.equal(to_gen_result(origin_id, [{ content: '/*1*/' }, { filename: 'foo2.ts', content: '/*2*/' }]), {
+        origin_id,
+        files: [
+            { id: resolve('src/foo.ts'), content: '/*1*/', origin_id, format: true },
+            { id: resolve('src/foo2.ts'), content: '/*2*/', origin_id, format: true },
+        ],
+    });
+});
+test__to_gen_result('complex array of raw files', () => {
+    assert.equal(to_gen_result(origin_id, [
+        { content: '/*1*/' },
+        { filename: 'foo2.ts', content: '/*2*/' },
+        { filename: 'foo3.ts', content: '/*3*/' },
+        { filename: 'foo4.ts', content: '/*4*/' },
+        { filename: 'foo5.json', content: '[/*5*/]' },
+    ]), {
+        origin_id,
+        files: [
+            { id: resolve('src/foo.ts'), content: '/*1*/', origin_id, format: true },
+            { id: resolve('src/foo2.ts'), content: '/*2*/', origin_id, format: true },
+            { id: resolve('src/foo3.ts'), content: '/*3*/', origin_id, format: true },
+            { id: resolve('src/foo4.ts'), content: '/*4*/', origin_id, format: true },
+            { id: resolve('src/foo5.json'), content: '[/*5*/]', origin_id, format: true },
+        ],
+    });
+});
+test__to_gen_result('fail with duplicate names because of omissions', () => {
+    assert.throws(() => {
+        to_gen_result(origin_id, [{ content: '/*1*/' }, { content: '/*2*/' }]);
+    });
+});
+test__to_gen_result('fail with duplicate explicit names', () => {
+    assert.throws(() => {
+        to_gen_result(origin_id, [
+            { filename: 'foo.ts', content: '/*1*/' },
+            { filename: 'foo.ts', content: '/*2*/' },
+        ]);
+    });
+});
+test__to_gen_result('fail with duplicate explicit and implicit names', () => {
+    assert.throws(() => {
+        to_gen_result(origin_id, [{ content: '/*1*/' }, { filename: 'foo.ts', content: '/*2*/' }]);
+    });
+});
+test__to_gen_result.run();
+/* test__to_gen_result */

package/dist/gen_module.d.ts

@@ -0,0 +1,46 @@
+import { type Module_Meta, type Load_Module_Result, type Find_Modules_Result } from './modules.js';
+import type { Gen, Gen_Results, Gen_File } from './gen.js';
+export declare const GEN_FILE_PATTERN_TEXT = "gen";
+export declare const GEN_FILE_PATTERN: string;
+export declare const is_gen_path: (path: string) => boolean;
+export declare const GEN_SCHEMA_FILE_PATTERN_TEXT = "schema";
+export declare const GEN_SCHEMA_FILE_PATTERN: string;
+export declare const GEN_SCHEMA_PATH_SUFFIX: string;
+export declare const GEN_SCHEMA_IDENTIFIER_SUFFIX = "Schema";
+export type Gen_Module_Type = 'basic';
+export type Gen_Module = Basic_Gen_Module | Schema_Gen_Module;
+export interface Basic_Gen_Module {
+    gen: Gen;
+}
+export interface Schema_Gen_Module extends Basic_Gen_Module {
+    [key: string]: unknown;
+}
+export declare const to_gen_module_type: (_filename: string) => Gen_Module_Type;
+export declare const gen_module_meta: Record<Gen_Module_Type, {
+    pattern: string;
+    text: string;
+}>;
+export declare const validate_gen_module: {
+    basic: (mod: Record<string, any>) => mod is Basic_Gen_Module;
+    schema: (mod: Record<string, any>) => mod is Schema_Gen_Module;
+};
+export type Gen_Module_Meta = Basic_Gen_Module_Meta;
+export interface Basic_Gen_Module_Meta extends Module_Meta<Gen_Module> {
+    type: 'basic';
+    mod: Basic_Gen_Module;
+}
+export declare const load_gen_module: (id: string) => Promise<Load_Module_Result<Gen_Module_Meta>>;
+export type Check_Gen_Module_Result = {
+    file: Gen_File;
+    existing_content: string;
+    is_new: false;
+    has_changed: boolean;
+} | {
+    file: Gen_File;
+    existing_content: null;
+    is_new: true;
+    has_changed: true;
+};
+export declare const check_gen_modules: (gen_results: Gen_Results) => Promise<Check_Gen_Module_Result[]>;
+export declare const check_gen_module: (file: Gen_File) => Promise<Check_Gen_Module_Result>;
+export declare const find_gen_modules: (input_paths?: string[], extensions?: string[], root_dirs?: string[]) => Promise<Find_Modules_Result>;

package/dist/gen_module.js

@@ -0,0 +1,54 @@
+import { readFile } from 'node:fs/promises';
+import { load_module, find_modules, } from './modules.js';
+import { get_possible_source_ids } from './input_path.js';
+import { paths } from './paths.js';
+import { search_fs } from './search_fs.js';
+import { exists } from './fs.js';
+export const GEN_FILE_PATTERN_TEXT = 'gen';
+export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
+export const is_gen_path = (path) => path.includes(GEN_FILE_PATTERN);
+export const GEN_SCHEMA_FILE_PATTERN_TEXT = 'schema';
+export const GEN_SCHEMA_FILE_PATTERN = '.' + GEN_SCHEMA_FILE_PATTERN_TEXT + '.';
+export const GEN_SCHEMA_PATH_SUFFIX = GEN_SCHEMA_FILE_PATTERN + 'ts';
+export const GEN_SCHEMA_IDENTIFIER_SUFFIX = 'Schema';
+// TODO remove if not used, but we may generic stuff from Zod schemas or other things
+export const to_gen_module_type = (_filename) => 'basic';
+export const gen_module_meta = {
+    basic: { pattern: GEN_FILE_PATTERN, text: GEN_FILE_PATTERN_TEXT },
+};
+export const validate_gen_module = {
+    basic: (mod) => typeof mod?.gen === 'function',
+    schema: (mod) => !!mod,
+};
+export const load_gen_module = async (id) => {
+    const type = to_gen_module_type(id);
+    const result = await load_module(id, validate_gen_module[type]);
+    if (result.ok) {
+        result.mod.type = type;
+    }
+    return result;
+};
+export const check_gen_modules = (gen_results) => Promise.all(gen_results.successes
+    .map((result) => result.files.map((file) => check_gen_module(file)))
+    .flat());
+export const check_gen_module = async (file) => {
+    if (!(await exists(file.id))) {
+        return {
+            file,
+            existing_content: null,
+            is_new: true,
+            has_changed: true,
+        };
+    }
+    const existing_content = await readFile(file.id, 'utf8');
+    return {
+        file,
+        existing_content,
+        is_new: false,
+        has_changed: file.content !== existing_content,
+    };
+};
+export const find_gen_modules = (input_paths = [paths.source], 
+// TODO improve this API to allow config, maybe just a simple `gen` filter function, so the user could return a Rollup pluginutils filter,
+// gets a little tricky with the `get_possible_source_ids` API usage, which would probably need to change
+extensions = [GEN_FILE_PATTERN, GEN_SCHEMA_FILE_PATTERN], root_dirs = []) => find_modules(input_paths, (id) => search_fs(id, { filter: (path) => extensions.some((e) => path.includes(e)) }), (input_path) => get_possible_source_ids(input_path, extensions, root_dirs));

package/dist/gen_module.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gen_module.test.js

@@ -0,0 +1,30 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { join } from 'node:path';
+import { validate_gen_module, find_gen_modules } from './gen_module.js';
+import { paths } from './paths.js';
+test('basic minimal interface', () => {
+    assert.ok(validate_gen_module.basic({ gen: Function.prototype }));
+});
+test('basic invalid module', () => {
+    assert.ok(!validate_gen_module.basic({ gen: {} }));
+    assert.ok(!validate_gen_module.basic({ task: { run: {} } }));
+    assert.ok(!validate_gen_module.basic(undefined));
+    assert.ok(!validate_gen_module.basic(null));
+    assert.ok(!validate_gen_module.basic(false));
+});
+test('schema minimal interface', () => {
+    assert.ok(validate_gen_module.schema({}));
+    assert.ok(validate_gen_module.schema({ SomeSchema: { $id: '/schemas/SomeSchema' } }));
+});
+test('schema invalid module', () => {
+    assert.ok(!validate_gen_module.schema(undefined));
+    assert.ok(!validate_gen_module.schema(null));
+    assert.ok(!validate_gen_module.schema(false));
+});
+test('finds gen modules in a directory', async () => {
+    const find_gen_modules_result = await find_gen_modules([join(paths.lib, 'docs/')]);
+    assert.ok(find_gen_modules_result.ok);
+    assert.ok(find_gen_modules_result.source_id_path_data_by_input_path.size);
+});
+test.run();

package/dist/git.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import type { Flavored } from '@ryanatkn/belt/types.js';
+import type { SpawnOptions } from 'child_process';
+import { z } from 'zod';
+export declare const Git_Origin: z.ZodString;
+export type Git_Origin = Flavored<z.infer<typeof Git_Origin>, 'Git_Origin'>;
+export declare const Git_Branch: z.ZodString;
+export type Git_Branch = Flavored<z.infer<typeof Git_Branch>, 'Git_Branch'>;
+/**
+ * Returns the current git branch name or throws if something goes wrong.
+ */
+export declare const git_current_branch_name: (options?: SpawnOptions) => Promise<string>;
+/**
+ * @returns a boolean indicating if the remote git branch exists
+ */
+export declare const git_remote_branch_exists: (origin?: Flavored<string, "Git_Origin">, branch?: any, options?: SpawnOptions) => Promise<boolean>;
+/**
+ * @returns a boolean indicating if the local git branch exists
+ */
+export declare const git_local_branch_exists: (branch: Flavored<string, "Git_Branch">, options?: SpawnOptions) => Promise<boolean>;
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged or uncommitted changes, or `null` if it's clean
+ */
+export declare const git_check_clean_workspace: (options?: SpawnOptions) => Promise<string | null>;
+/**
+ * Calls `git fetch` and throws if anything goes wrong.
+ */
+export declare const git_fetch: (origin?: Flavored<string, "Git_Origin">, branch?: any, options?: SpawnOptions) => Promise<void>;
+/**
+ * Calls `git checkout` and throws if anything goes wrong.
+ * @returns the previous branch name, if it changed
+ */
+export declare const git_checkout: (branch: Flavored<string, "Git_Branch">, options?: SpawnOptions) => Promise<Git_Branch | null>;
+/**
+ * Calls `git pull` and throws if anything goes wrong.
+ */
+export declare const git_pull: (origin?: Flavored<string, "Git_Origin">, branch?: any, options?: SpawnOptions) => Promise<void>;
+/**
+ * Calls `git push` and throws if anything goes wrong.
+ */
+export declare const git_push: (origin: Flavored<string, "Git_Origin">, branch: Flavored<string, "Git_Branch">, options?: SpawnOptions) => Promise<void>;
+/**
+ * Calls `git push` and throws if anything goes wrong.
+ */
+export declare const git_push_to_create: (origin?: Flavored<string, "Git_Origin">, branch?: any, options?: SpawnOptions) => Promise<void>;
+/**
+ * Deletes a branch locally and throws if anything goes wrong.
+ */
+export declare const git_delete_local_branch: (branch: Flavored<string, "Git_Branch">, options?: SpawnOptions) => Promise<void>;
+/**
+ * Deletes a branch remotely and throws if anything goes wrong.
+ */
+export declare const git_delete_remote_branch: (origin: Flavored<string, "Git_Origin">, branch: Flavored<string, "Git_Branch">, options?: SpawnOptions) => Promise<void>;
+/**
+ * Resets the `target` branch back to its first commit both locally and remotely.
+ */
+export declare const git_reset_branch_to_first_commit: (origin: Flavored<string, "Git_Origin">, branch: Flavored<string, "Git_Branch">, options?: SpawnOptions) => Promise<void>;
+/**
+ * Returns the branch's latest commit hash or throws if something goes wrong.
+ */
+export declare const git_current_commit_hash: (branch?: string, options?: SpawnOptions) => Promise<string | null>;
+/**
+ * Returns the hash of the current branch's first commit or throws if something goes wrong.
+ */
+export declare const git_current_branch_first_commit_hash: (options?: SpawnOptions) => Promise<string>;
+/**
+ * Returns the global git config setting for `pull.rebase`.
+ * Gro is currently written to expect `true`,
+ * but the restriction could be loosened with additional work.
+ */
+export declare const git_check_setting_pull_rebase: (options?: SpawnOptions) => Promise<boolean>;
+/**
+ * Clones a branch locally to another directory and updates the origin to match the source.
+ */
+export declare const git_clone_locally: (origin: Flavored<string, "Git_Origin">, branch: Flavored<string, "Git_Branch">, source_dir: string, target_dir: string, options?: SpawnOptions) => Promise<void>;