@doki-land/nifty 0.1.1 → 0.1.2

package/src/config/detectProject.ts

@@ -6,74 +6,74 @@ export type ProjectKind = "cargo" | "npm" | "hybrid" | "unknown";
 /** Detected cargo + npm project layout. */
 export type ProjectLayout = {
     /** Resolved project root (git root when present). */
-    root : string;
-    kind : ProjectKind;
+    root: string;
+    kind: ProjectKind;
     /** Nearest `Cargo.toml` walking upward. */
-    cargoManifest ? : string;
+    cargoManifest?: string;
     /** Nearest `package.json` walking upward (skips `node_modules`). */
-    packageManifest ? : string;
+    packageManifest?: string;
     /** Directory whose `Cargo.toml` declares a `[workspace]`. */
-    cargoWorkspaceRoot ? : string;
+    cargoWorkspaceRoot?: string;
     /** Directory whose `package.json` declares npm `workspaces`. */
-    npmWorkspaceRoot ? : string;
+    npmWorkspaceRoot?: string;
 };
 
 const CARGO_MANIFEST = "Cargo.toml";
 const PACKAGE_MANIFEST = "package.json";
 const GIT_DIR = ".git";
 
-function isInsideNodeModules(path : string) : boolean {
-    return path.split( /[/\\]/ ).includes("node_modules");
+function isInsideNodeModules(path: string): boolean {
+    return path.split(/[/\\]/).includes("node_modules");
 }
 
-function findFileUpward(cwd : string, fileName : string, skipNodeModules : boolean) : string | undefined {
+function findFileUpward(cwd: string, fileName: string, skipNodeModules: boolean): string | undefined {
     let here = resolve(cwd);
-    while(true){
-        if(skipNodeModules && isInsideNodeModules(here)){
+    while (true) {
+        if (skipNodeModules && isInsideNodeModules(here)) {
             const parent = dirname(here);
-            if(parent === here){
+            if (parent === here) {
                 return undefined;
             }
             here = parent;
             continue;
         }
         const candidate = join(here, fileName);
-        if(existsSync(candidate)){
+        if (existsSync(candidate)) {
             return candidate;
         }
         const parent = dirname(here);
-        if(parent === here){
+        if (parent === here) {
             return undefined;
         }
         here = parent;
     }
 }
 
-function findGitRoot(cwd : string) : string | undefined {
+function findGitRoot(cwd: string): string | undefined {
     let here = resolve(cwd);
-    while(true){
-        if(existsSync(join(here, GIT_DIR))){
+    while (true) {
+        if (existsSync(join(here, GIT_DIR))) {
             return here;
         }
         const parent = dirname(here);
-        if(parent === here){
+        if (parent === here) {
             return undefined;
         }
         here = parent;
     }
 }
 
-function manifestHasCargoWorkspace(manifestPath : string) : boolean {
+function manifestHasCargoWorkspace(manifestPath: string): boolean {
     try {
         return readFileSync(manifestPath, "utf8")
-            .split( /\r?\n/ )
-            .some((line) =>line.trim() === "[workspace]");
+            .split(/\r?\n/)
+            .some((line) => line.trim() === "[workspace]");
     } catch {
         return false;
     }
 }
 
-function manifestHasNpmWorkspaces(manifestPath : string) : boolean {
+function manifestHasNpmWorkspaces(manifestPath: string): boolean {
     try {
         return readFileSync(manifestPath, "utf8").includes('"workspaces"');
     } catch {
@@ -81,61 +81,61 @@ function manifestHasNpmWorkspaces(manifestPath : string) : boolean {
     }
 }
 
-function findCargoWorkspaceRoot(manifestPath : string) : string | undefined {
+function findCargoWorkspaceRoot(manifestPath: string): string | undefined {
     let here = dirname(resolve(manifestPath));
-    while(true){
+    while (true) {
         const candidate = join(here, CARGO_MANIFEST);
-        if(existsSync(candidate) && manifestHasCargoWorkspace(candidate)){
+        if (existsSync(candidate) && manifestHasCargoWorkspace(candidate)) {
             return here;
         }
         const parent = dirname(here);
-        if(parent === here){
+        if (parent === here) {
             return undefined;
         }
         here = parent;
     }
 }
 
-function findNpmWorkspaceRoot(manifestPath : string) : string | undefined {
+function findNpmWorkspaceRoot(manifestPath: string): string | undefined {
     let here = dirname(resolve(manifestPath));
-    while(true){
+    while (true) {
         const candidate = join(here, PACKAGE_MANIFEST);
-        if(existsSync(candidate) && manifestHasNpmWorkspaces(candidate)){
+        if (existsSync(candidate) && manifestHasNpmWorkspaces(candidate)) {
             return here;
         }
         const parent = dirname(here);
-        if(parent === here){
+        if (parent === here) {
             return undefined;
         }
         here = parent;
     }
 }
 
-function classifyProject(hasCargo : boolean, hasNpm : boolean) : ProjectKind {
-    if(hasCargo && hasNpm){
+function classifyProject(hasCargo: boolean, hasNpm: boolean): ProjectKind {
+    if (hasCargo && hasNpm) {
         return "hybrid";
     }
-    if(hasCargo){
+    if (hasCargo) {
         return "cargo";
     }
-    if(hasNpm){
+    if (hasNpm) {
         return "npm";
     }
     return "unknown";
 }
 
 /** Walk upward and return the nearest `Cargo.toml`. */
-export function findCargoManifest(cwd = process.cwd()) : string | undefined {
+export function findCargoManifest(cwd = process.cwd()): string | undefined {
     return findFileUpward(cwd, CARGO_MANIFEST, false);
 }
 
 /** Walk upward and return the nearest `package.json` (skips `node_modules`). */
-export function findPackageManifest(cwd = process.cwd()) : string | undefined {
+export function findPackageManifest(cwd = process.cwd()): string | undefined {
     return findFileUpward(cwd, PACKAGE_MANIFEST, true);
 }
 
 /** Detect cargo/npm/hybrid layout from `cwd`. */
-export function detectProjectLayout(cwd = process.cwd()) : ProjectLayout {
+export function detectProjectLayout(cwd = process.cwd()): ProjectLayout {
     const start = resolve(cwd);
     const cargoManifest = findCargoManifest(start);
     const packageManifest = findPackageManifest(start);
@@ -161,24 +161,24 @@ export function detectProjectLayout(cwd = process.cwd()) : ProjectLayout {
 }
 
 /** Discover npm package directories for hybrid monorepos. */
-export function discoverPackageDirs(layout : ProjectLayout) : string[]{
-    const roots = new Set<string>();
+export function discoverPackageDirs(layout: ProjectLayout): string[] {
+    const roots = new Set < string> ();
 
-    if(layout.npmWorkspaceRoot){
+    if (layout.npmWorkspaceRoot) {
         roots.add(layout.npmWorkspaceRoot);
     }
-    if(layout.packageManifest){
+    if (layout.packageManifest) {
         roots.add(dirname(layout.packageManifest));
     }
-    if(layout.kind === "hybrid"){
+    if (layout.kind === "hybrid") {
         const packagesDir = join(layout.root, "projects", "packages");
-        if(existsSync(packagesDir)){
-            for(const entry of readdirSync(packagesDir, { withFileTypes : true })){
-                if(!entry.isDirectory()){
+        if (existsSync(packagesDir)) {
+            for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+                if (!entry.isDirectory()) {
                     continue;
                 }
                 const packageJson = join(packagesDir, entry.name, "package.json");
-                if(existsSync(packageJson)){
+                if (existsSync(packageJson)) {
                     roots.add(join(packagesDir, entry.name));
                 }
             }

package/src/config/formatPresets.ts

@@ -1,19 +1,19 @@
 import type { NiftyFormatConfig, NiftyFormatPreset, NiftyFormatStyleConfig } from "./types.js";
 
 export type ResolvedFormatOptions = {
-    preset : NiftyFormatPreset;
-    includes ? : string[];
-    excludes ? : string[];
-    rust ? : boolean;
-    javascript ? : boolean;
-    style : NiftyFormatStyleConfig;
+    preset: NiftyFormatPreset;
+    includes?: string[];
+    excludes?: string[];
+    rust?: boolean;
+    javascript?: boolean;
+    style: NiftyFormatStyleConfig;
 };
 
-const DEFAULT_FORMAT_STYLE : NiftyFormatStyleConfig = {
-    indentStyle : "space",
-    indentWidth : 4,
-    lineWidth : 144,
-    quoteStyle : "single",
+const DEFAULT_FORMAT_STYLE: NiftyFormatStyleConfig = {
+    indentStyle: "space",
+    indentWidth: 4,
+    lineWidth: 144,
+    quoteStyle: "single",
 };
 
 const NIFTY_PRESET_INCLUDES = [
@@ -39,26 +39,26 @@ const VMZ_INCLUDES = [
     "nifty.config.ts",
 ]as const;
 
-const PRESET_INCLUDES : Record<NiftyFormatPreset, readonly string[] | undefined> = {
-    default : undefined,
-    nifty : NIFTY_PRESET_INCLUDES,
-    "npm-tools" : NIFTY_PRESET_INCLUDES,
-    vmz : VMZ_INCLUDES,
+const PRESET_INCLUDES: Record < NiftyFormatPreset, readonly string[] | undefined > = {
+    default: undefined,
+    nifty: NIFTY_PRESET_INCLUDES,
+    "npm-tools": NIFTY_PRESET_INCLUDES,
+    vmz: VMZ_INCLUDES,
 };
 
 /** Merge `nifty.config` `format` with built-in preset defaults. */
-export function resolveFormatConfig(format : NiftyFormatConfig | undefined) : ResolvedFormatOptions {
-    const preset = format ?.preset ?? "default";
+export function resolveFormatConfig(format: NiftyFormatConfig | undefined): ResolvedFormatOptions {
+    const preset = format?.preset ?? "default";
     const presetIncludes = PRESET_INCLUDES[preset];
     return {
         preset,
-        includes : format ?.includes ?? (presetIncludes ? [...presetIncludes] : undefined),
-        excludes : format ?.excludes,
-        rust : format ?.rust,
-        javascript : format ?.javascript,
-        style : {
+        includes: format?.includes ?? (presetIncludes ? [...presetIncludes] : undefined),
+        excludes: format?.excludes,
+        rust: format?.rust,
+        javascript: format?.javascript,
+        style: {
             ...DEFAULT_FORMAT_STYLE,
-            ...format ?.style,
+            ...format?.style,
         },
     };
 }

package/src/config/loadConfig.ts

@@ -8,23 +8,23 @@ import { detectProjectLayout } from "./detectProject.js";
 
 export type LoadConfigOptions = {
     /** Directory to start searching from (defaults to `process.cwd()`). */
-    cwd ? : string;
+    cwd?: string;
     /** When set, skip searching and load this file directly. */
-    configFile ? : string;
+    configFile?: string;
     /** Passed to functional configs: `export default defineConfig(({ mode }) => ...)`. */
-    env ? : Partial<NiftyConfigEnv>;
+    env?: Partial < NiftyConfigEnv> ;
     /**
      * When true (default), write `nifty.config.ts` at the detected project root if missing.
      * Set false for `--dry-run` so commands only report what would happen.
      */
-    createIfMissing ? : boolean;
+    createIfMissing?: boolean;
 };
 
 export type LoadedNiftyConfig = {
-    config : NiftyConfig;
-    configFile ? : string;
+    config: NiftyConfig;
+    configFile?: string;
     /** True when this run created a new config file. */
-    created ? : boolean;
+    created?: boolean;
 };
 
 const DEFAULT_CONFIG_TEMPLATE = `// Nifty project configuration.
@@ -32,24 +32,24 @@ const DEFAULT_CONFIG_TEMPLATE = `// Nifty project configuration.
 export default {};
 `;
 
-const DEFAULT_ENV = (cwd : string) : NiftyConfigEnv =>({
-    mode : process.env.NODE_ENV ?? "development",
-    command : "serve",
-    layout : detectProjectLayout(cwd),
+const DEFAULT_ENV = (cwd: string): NiftyConfigEnv => ({
+    mode: process.env.NODE_ENV ?? "development",
+    command: "serve",
+    layout: detectProjectLayout(cwd),
 });
 
 /** Walk upward and return the nearest existing Nifty config file. */
-export function findConfigFile(cwd = process.cwd()) : string | undefined {
+export function findConfigFile(cwd = process.cwd()): string | undefined {
     let here = resolve(cwd);
-    while(true){
-        for(const name of CONFIG_FILE_NAMES){
+    while (true) {
+        for (const name of CONFIG_FILE_NAMES) {
             const candidate = join(here, name);
-            if(existsSync(candidate)){
+            if (existsSync(candidate)) {
                 return candidate;
             }
         }
         const parent = dirname(here);
-        if(parent === here){
+        if (parent === here) {
             return undefined;
         }
         here = parent;
@@ -57,21 +57,21 @@ export function findConfigFile(cwd = process.cwd()) : string | undefined {
 }
 
 /** Default config path at the detected project root (prefers `nifty.config.ts`). */
-export function defaultConfigPath(cwd = process.cwd()) : string {
+export function defaultConfigPath(cwd = process.cwd()): string {
     const layout = detectProjectLayout(cwd);
     return join(layout.root, CONFIG_FILE_NAMES[0]);
 }
 
 /** Warn and optionally create a default config when none exists. */
-export function ensureConfigFile(options : { cwd ? : string; create ? : boolean } = { }) : string | undefined {
+export function ensureConfigFile(options: { cwd?: string; create?: boolean } = { }): string | undefined {
     const cwd = options.cwd ?? process.cwd();
     const existing = findConfigFile(cwd);
-    if(existing){
+    if (existing) {
         return existing;
     }
 
     const target = defaultConfigPath(cwd);
-    if(options.create){
+    if (options.create) {
         writeFileSync(target, DEFAULT_CONFIG_TEMPLATE, "utf8");
         console.warn(`nifty: no config found, created default ${target}`);
         return target;
@@ -81,40 +81,40 @@ export function ensureConfigFile(options : { cwd ? : string; create ? : boolean
     return undefined;
 }
 
-function normalizeExport(raw : unknown) : NiftyConfigExport {
-    if(raw && typeof raw === "object" && "default" in raw){
-        return(raw as { default : NiftyConfigExport }).default;
+function normalizeExport(raw: unknown): NiftyConfigExport {
+    if (raw && typeof raw === "object" && "default" in raw) {
+        return(raw as { default: NiftyConfigExport }).default;
     }
     return raw as NiftyConfigExport;
 }
 
-async function resolveExport(exported : NiftyConfigExport, env : NiftyConfigEnv) : Promise<NiftyConfig>{
-    if(typeof exported === "function"){
+async function resolveExport(exported: NiftyConfigExport, env: NiftyConfigEnv): Promise < NiftyConfig> {
+    if (typeof exported === "function") {
         return await exported(env);
     }
     return exported;
 }
 
 /** Load `nifty.config.ts/js`, creating a default file at the project root when missing. */
-export async function loadConfig(options : LoadConfigOptions = { }) : Promise<LoadedNiftyConfig>{
+export async function loadConfig(options: LoadConfigOptions = { }): Promise < LoadedNiftyConfig> {
     const cwd = options.cwd ?? process.cwd();
     let configFile = options.configFile ?? findConfigFile(cwd);
     let created = false;
 
-    if(!configFile && options.createIfMissing!== false){
-        configFile = ensureConfigFile({ cwd, create : true });
+    if (!configFile && options.createIfMissing !== false) {
+        configFile = ensureConfigFile({ cwd, create: true });
         created = Boolean(configFile);
-    } else if(!configFile){
-        ensureConfigFile({ cwd, create : false });
-        return { config : { } };
+    } else if (!configFile) {
+        ensureConfigFile({ cwd, create: false });
+        return { config: { } };
     }
 
-    if(!configFile){
-        return { config : { } };
+    if (!configFile) {
+        return { config: { } };
     }
 
-    const env : NiftyConfigEnv = { ...DEFAULT_ENV(cwd), ...options.env };
-    const jiti = createJiti(import.meta.url, { interopDefault : true });
+    const env: NiftyConfigEnv = { ...DEFAULT_ENV(cwd), ...options.env };
+    const jiti = createJiti(import.meta.url, { interopDefault: true });
     const mod = await jiti.import(configFile);
     const config = await resolveExport(normalizeExport(mod), env);
     return { config, configFile, created };

package/src/config/trustPayload.ts

@@ -1,14 +1,14 @@
 import type { NiftyConfig } from "./types.js";
 
 /** Map `nifty.config` `trust.npm` into native publisher options. */
-export function trustPayloadFromConfig(config : NiftyConfig){
-    const npm = config.trust ?.npm;
-    if(!npm){
+export function trustPayloadFromConfig(config: NiftyConfig) {
+    const npm = config.trust?.npm;
+    if (!npm) {
         return { };
     }
     return {
-        ...(npm.repo ? { trustRepo : npm.repo } : { }),
-        ...(npm.file ? { trustFile : npm.file } : { }),
-        ...(npm.environment ? { trustEnvironment : npm.environment } : { }),
+        ...(npm.repo ? { trustRepo: npm.repo } : { }),
+        ...(npm.file ? { trustFile: npm.file } : { }),
+        ...(npm.environment ? { trustEnvironment: npm.environment } : { }),
     };
 }

package/src/config/types.ts

@@ -1,7 +1,7 @@
 /** One email → GitHub author row in `author-github.json`. */
 export type NiftyAuthorEntry = {
-    id ? : number;
-    login ? : string;
+    id?: number;
+    login?: string;
 };
 
 /** Built-in workspace format presets (`nifty.config` `format.preset`). */
@@ -10,97 +10,97 @@ export type NiftyFormatPreset = "default" | "nifty" | "npm-tools" | "vmz";
 /** Oak formatter style knobs (`nifty.config` `format.style`). */
 export type NiftyFormatStyleConfig = {
     /** Indent with spaces or tabs (default: `space`). */
-    indentStyle ? : "space" | "tab";
+    indentStyle?: "space" | "tab";
     /** Spaces or tabs per indent level (default: `4`). */
-    indentWidth ? : number;
+    indentWidth?: number;
     /** Soft line width (default: `144`). */
-    lineWidth ? : number;
+    lineWidth?: number;
     /** String quote preference (default: `single`). */
-    quoteStyle ? : "single" | "double";
+    quoteStyle?: "single" | "double";
 };
 
 /** npm Trusted Publisher target for `nifty trust` (GitHub Actions OIDC). */
 export type NiftyTrustNpmConfig = {
     /** GitHub `owner/repo` for the publishing workflow. */
-    repo ? : string;
+    repo?: string;
     /** Workflow filename, e.g. `release-npm.yml`. */
-    file ? : string;
+    file?: string;
     /** GitHub Environment name, e.g. `NPM_PUBLISH`. */
-    environment ? : string;
+    environment?: string;
 };
 
 /** Trusted publisher wiring (`nifty trust`). Only `npm` is supported today. */
 export type NiftyTrustConfig = {
-    npm ? : NiftyTrustNpmConfig;
+    npm?: NiftyTrustNpmConfig;
 };
 
 /** Workspace format options (`nifty format` reads `nifty.config` `format`). */
 export type NiftyFormatConfig = {
     /** Select built-in include roots for Nifty hybrid monorepos. */
-    preset ? : NiftyFormatPreset;
+    preset?: NiftyFormatPreset;
     /** Extra include globs (override preset list when set alone). */
-    includes ? : string[];
+    includes?: string[];
     /** Skip paths under these globs after includes expand. */
-    excludes ? : string[];
+    excludes?: string[];
     /** Run `cargo fmt` (default: true when a Cargo workspace is detected). */
-    rust ? : boolean;
+    rust?: boolean;
     /** Run Oak formatting on JS/TS targets (default: true). */
-    javascript ? : boolean;
+    javascript?: boolean;
     /** Inline Oak formatter style (not an external config file path). */
-    style ? : NiftyFormatStyleConfig;
+    style?: NiftyFormatStyleConfig;
 };
 
 /** Nifty project configuration (`nifty.config.ts` / `nifty.config.js`). */
 export type NiftyConfig = {
     /** GitHub personal access token for email search / profile fetch. */
-    githubToken ? : string;
+    githubToken?: string;
     /** Path to `author-github.json` (default: `documentation/maintenance/author-github.json`). */
-    authorMap ? : string;
+    authorMap?: string;
     /** Repository root override when discovering git metadata. */
-    repoRoot ? : string;
+    repoRoot?: string;
     /** Cargo workspace / crate root override. */
-    cargoRoot ? : string;
+    cargoRoot?: string;
     /** npm package root override. */
-    npmRoot ? : string;
+    npmRoot?: string;
     /** npm publish / Trusted Publisher (CI uses publish-npm.yml). */
-    publish ? : {
+    publish?: {
         /**
          * Optional narrow subset for `nifty publish` / `nifty trust`.
          * Default: every workspace package that is not `private: true` (and not blocked by a private dep).
          */
-        packages ? : string[];
+        packages?: string[];
     };
     /**
      * Trusted publisher wiring for `nifty trust`.
      * Prefer `trust.npm` over `NIFTY_TRUST_*` env vars. `nifty trust` uses the npm registry API.
      */
-    trust ? : NiftyTrustConfig;
+    trust?: NiftyTrustConfig;
     /** Release reference changelog defaults (`nifty change-logs`). */
-    changelog ? : {
+    changelog?: {
         /** GitHub `owner/repo` for contrib.rocks (default: parse `origin`). */
-        repo ? : string;
+        repo?: string;
         /** `--write` output directory (default: `documentation/maintenance/releases`). */
-        releasesDir ? : string;
+        releasesDir?: string;
     };
     /** Rule-based lint configuration. */
-    lint ? : {
-        rules ? : Array<{
-            id : string;
-            enabled ? : boolean;
-            severity ? : "error" | "warning" | "info";
+    lint?: {
+        rules?: Array < {
+            id: string;
+            enabled?: boolean;
+            severity?: "error" | "warning" | "info";
         }>;
     };
     /** Workspace format targets and engines (`nifty format`). */
-    format ? : NiftyFormatConfig;
+    format?: NiftyFormatConfig;
 };
 
-export type NiftyConfigExport = NiftyConfig | ((env : NiftyConfigEnv) =>NiftyConfig | Promise<NiftyConfig>);
+export type NiftyConfigExport = NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise < NiftyConfig> );
 
 export type NiftyConfigEnv = {
-    mode : string;
-    command : string;
+    mode: string;
+    command: string;
     /** Detected cargo + npm project layout for hybrid monorepos. */
-    layout : import("./detectProject.js").ProjectLayout;
+    layout: import("./detectProject.js").ProjectLayout;
 };
 
 export const CONFIG_FILE_NAMES = [

package/src/git.ts

@@ -2,60 +2,60 @@ import type { CommitRecord, RangeInfo, TagInfo } from "./types.js";
 import { loadNiftyNative, mapCommitRecord, mapRangeInfo, mapTagInfo, type GitExports } from "./native.js";
 
 export type ResolveRangeOptions = {
-    version ? : string;
-    fromRef ? : string;
-    toRef ? : string;
+    version?: string;
+    fromRef?: string;
+    toRef?: string;
 };
 
 /**
  * Read-only git repository helpers (gix via Node-API, no `git` subprocess).
  */
 export class Git {
-    constructor(private readonly wasm : GitExports){ }
+    constructor(private readonly wasm: GitExports) { }
 
-    static open() : Git {
+    static open(): Git {
         const native = loadNiftyNative();
         return new Git(native.git);
     }
 
     /** Walk upward from `startPath` to find the working tree root containing `.git`. */
-    discoverRoot(startPath : string) : string {
+    discoverRoot(startPath: string): string {
         return this.wasm["discover-root"](startPath);
     }
 
     /** List `v*` tags sorted by semver. */
-    listVersionTags(repoRoot : string) : string[]{
+    listVersionTags(repoRoot: string): string[] {
         return this.wasm["list-version-tags"](repoRoot);
     }
 
-    listTagInfos(repoRoot : string) : TagInfo[]{
+    listTagInfos(repoRoot: string): TagInfo[] {
         return this.wasm["list-tag-infos"](repoRoot).map(mapTagInfo);
     }
 
-    formatTagList(repoRoot : string) : string {
+    formatTagList(repoRoot: string): string {
         return this.wasm["format-tag-list"](repoRoot);
     }
 
-    resolveRange(repoRoot : string, options : ResolveRangeOptions = { }) : RangeInfo {
+    resolveRange(repoRoot: string, options: ResolveRangeOptions = { }): RangeInfo {
         return mapRangeInfo(
             this.wasm["resolve-range"](repoRoot, options.version, options.fromRef, options.toRef),
         );
     }
 
     /** Collect non-merge commits in `fromRef..toRef` (exclusive..inclusive). */
-    collectCommits(repoRoot : string, fromRef : string | undefined, toRef : string) : CommitRecord[]{
+    collectCommits(repoRoot: string, fromRef: string | undefined, toRef: string): CommitRecord[] {
         return this.wasm["collect-commits"](repoRoot, fromRef, toRef).map(mapCommitRecord);
     }
 
-    detectGithubRepo(repoRoot : string) : string | undefined {
+    detectGithubRepo(repoRoot: string): string | undefined {
         return this.wasm["detect-github-repo"](repoRoot);
     }
 
-    parseGithubRemote(url : string) : string | undefined {
+    parseGithubRemote(url: string): string | undefined {
         return this.wasm["parse-github-remote"](url);
     }
 }
 
-export function createGit() : Git {
+export function createGit(): Git {
     return Git.open();
 }