@solaqua/gji 0.6.2 → 0.7.1

package/dist/package-manager.js

@@ -1,70 +1,121 @@
-import { access, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { access, readdir } from "node:fs/promises";
+import { join } from "node:path";
 const ENTRIES = [
     // JavaScript / TypeScript
-    { name: 'pnpm', signals: ['pnpm-lock.yaml'], command: 'pnpm install' },
-    { name: 'yarn', signals: ['yarn.lock'], command: 'yarn install' },
-    { name: 'bun', signals: ['bun.lockb'], command: 'bun install' },
-    { name: 'npm', signals: ['package-lock.json'], command: 'npm install' },
-    { name: 'deno', signals: ['deno.json', 'deno.jsonc'], command: 'deno cache' },
+    { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
+    { name: "yarn", signals: ["yarn.lock"], command: "yarn install" },
+    { name: "bun", signals: ["bun.lockb"], command: "bun install" },
+    { name: "npm", signals: ["package-lock.json"], command: "npm install" },
+    { name: "deno", signals: ["deno.json", "deno.jsonc"], command: "deno cache" },
     // Python
-    { name: 'poetry', signals: ['poetry.lock'], command: 'poetry install' },
-    { name: 'uv', signals: ['uv.lock'], command: 'uv sync' },
-    { name: 'pipenv', signals: ['Pipfile.lock'], command: 'pipenv install' },
-    { name: 'pdm', signals: ['pdm.lock'], command: 'pdm install' },
-    { name: 'conda-lock', signals: ['conda-lock.yml'], command: 'conda-lock install' },
-    { name: 'conda', signals: ['environment.yml'], command: 'conda env update --file environment.yml' },
+    { name: "poetry", signals: ["poetry.lock"], command: "poetry install" },
+    { name: "uv", signals: ["uv.lock"], command: "uv sync" },
+    { name: "pipenv", signals: ["Pipfile.lock"], command: "pipenv install" },
+    { name: "pdm", signals: ["pdm.lock"], command: "pdm install" },
+    {
+        name: "conda-lock",
+        signals: ["conda-lock.yml"],
+        command: "conda-lock install",
+    },
+    {
+        name: "conda",
+        signals: ["environment.yml"],
+        command: "conda env update --file environment.yml",
+    },
     // R
-    { name: 'renv', signals: ['renv.lock'], command: "Rscript -e 'renv::restore()'" },
+    {
+        name: "renv",
+        signals: ["renv.lock"],
+        command: "Rscript -e 'renv::restore()'",
+    },
     // Rust
-    { name: 'cargo', signals: ['Cargo.lock'], command: 'cargo build' },
+    { name: "cargo", signals: ["Cargo.lock"], command: "cargo build" },
     // Go
-    { name: 'go', signals: ['go.sum'], command: 'go mod download' },
+    { name: "go", signals: ["go.sum"], command: "go mod download" },
     // Ruby
-    { name: 'bundler', signals: ['Gemfile.lock'], command: 'bundle install' },
+    { name: "bundler", signals: ["Gemfile.lock"], command: "bundle install" },
     // PHP
-    { name: 'composer', signals: ['composer.lock'], command: 'composer install' },
+    { name: "composer", signals: ["composer.lock"], command: "composer install" },
     // Elixir / Erlang
-    { name: 'mix', signals: ['mix.lock'], command: 'mix deps.get' },
-    { name: 'rebar3', signals: ['rebar.lock'], command: 'rebar3 deps' },
+    { name: "mix", signals: ["mix.lock"], command: "mix deps.get" },
+    { name: "rebar3", signals: ["rebar.lock"], command: "rebar3 deps" },
     // Dart / Flutter
-    { name: 'dart', signals: ['pubspec.lock'], command: 'dart pub get' },
+    { name: "dart", signals: ["pubspec.lock"], command: "dart pub get" },
     // Java / Kotlin / Scala
-    { name: 'maven', signals: ['pom.xml'], command: 'mvn install' },
-    { name: 'gradle', signals: ['gradlew'], command: './gradlew build' },
-    { name: 'gradle', signals: ['build.gradle', 'build.gradle.kts'], command: 'gradle build' },
-    { name: 'sbt', signals: ['build.sbt'], command: 'sbt compile' },
+    { name: "maven", signals: ["pom.xml"], command: "mvn install" },
+    { name: "gradle", signals: ["gradlew"], command: "./gradlew build" },
+    {
+        name: "gradle",
+        signals: ["build.gradle", "build.gradle.kts"],
+        command: "gradle build",
+    },
+    { name: "sbt", signals: ["build.sbt"], command: "sbt compile" },
     // .NET (C# / F# / VB)
-    { name: 'dotnet', signals: ['*.sln', '*.csproj', '*.fsproj', '*.vbproj'], command: 'dotnet restore', glob: true },
+    {
+        name: "dotnet",
+        signals: ["*.sln", "*.csproj", "*.fsproj", "*.vbproj"],
+        command: "dotnet restore",
+        glob: true,
+    },
     // Swift
-    { name: 'swift', signals: ['Package.swift'], command: 'swift package resolve' },
+    {
+        name: "swift",
+        signals: ["Package.swift"],
+        command: "swift package resolve",
+    },
     // Haskell
-    { name: 'stack', signals: ['stack.yaml'], command: 'stack build' },
-    { name: 'cabal', signals: ['cabal.project'], command: 'cabal install --only-dependencies' },
-    { name: 'cabal', signals: ['*.cabal'], command: 'cabal install --only-dependencies', glob: true },
+    { name: "stack", signals: ["stack.yaml"], command: "stack build" },
+    {
+        name: "cabal",
+        signals: ["cabal.project"],
+        command: "cabal install --only-dependencies",
+    },
+    {
+        name: "cabal",
+        signals: ["*.cabal"],
+        command: "cabal install --only-dependencies",
+        glob: true,
+    },
     // Clojure
-    { name: 'clojure', signals: ['deps.edn'], command: 'clojure -P' },
-    { name: 'leiningen', signals: ['project.clj'], command: 'lein deps' },
+    { name: "clojure", signals: ["deps.edn"], command: "clojure -P" },
+    { name: "leiningen", signals: ["project.clj"], command: "lein deps" },
     // OCaml
-    { name: 'dune', signals: ['dune-project'], command: 'dune build' },
+    { name: "dune", signals: ["dune-project"], command: "dune build" },
     // Julia
-    { name: 'julia', signals: ['Manifest.toml'], command: "julia --project -e 'using Pkg; Pkg.instantiate()'" },
+    {
+        name: "julia",
+        signals: ["Manifest.toml"],
+        command: "julia --project -e 'using Pkg; Pkg.instantiate()'",
+    },
     // Nim
-    { name: 'nimble', signals: ['*.nimble'], command: 'nimble install', glob: true },
+    {
+        name: "nimble",
+        signals: ["*.nimble"],
+        command: "nimble install",
+        glob: true,
+    },
     // Crystal
-    { name: 'shards', signals: ['shard.yml'], command: 'shards install' },
+    { name: "shards", signals: ["shard.yml"], command: "shards install" },
     // Perl
-    { name: 'cpanm', signals: ['cpanfile'], command: 'cpanm --installdeps .' },
+    { name: "cpanm", signals: ["cpanfile"], command: "cpanm --installdeps ." },
     // Zig
-    { name: 'zig', signals: ['build.zig.zon'], command: 'zig build' },
+    { name: "zig", signals: ["build.zig.zon"], command: "zig build" },
     // C / C++
-    { name: 'vcpkg', signals: ['vcpkg.json'], command: 'vcpkg install' },
-    { name: 'conan', signals: ['conanfile.py', 'conanfile.txt'], command: 'conan install .' },
+    { name: "vcpkg", signals: ["vcpkg.json"], command: "vcpkg install" },
+    {
+        name: "conan",
+        signals: ["conanfile.py", "conanfile.txt"],
+        command: "conan install .",
+    },
     // Nix
-    { name: 'nix', signals: ['flake.nix'], command: 'nix develop' },
-    { name: 'nix-shell', signals: ['shell.nix'], command: 'nix-shell' },
+    { name: "nix", signals: ["flake.nix"], command: "nix develop" },
+    { name: "nix-shell", signals: ["shell.nix"], command: "nix-shell" },
     // Terraform / OpenTofu
-    { name: 'terraform', signals: ['terraform.lock.hcl'], command: 'terraform init' },
+    {
+        name: "terraform",
+        signals: ["terraform.lock.hcl"],
+        command: "terraform init",
+    },
 ];
 export async function detectPackageManager(repoRoot) {
     for (const entry of ENTRIES) {
@@ -102,7 +153,7 @@ async function matchesGlob(repoRoot, patterns) {
 }
 function patternToRegex(pattern) {
     const escaped = pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '[^/]*');
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, "[^/]*");
     return new RegExp(`^${escaped}$`);
 }

package/dist/pr.d.ts

@@ -1,5 +1,5 @@
-import { type PathConflictChoice } from './conflict.js';
-import { type InstallPromptDependencies } from './install-prompt.js';
+import { type PathConflictChoice } from "./conflict.js";
+import { type InstallPromptDependencies } from "./install-prompt.js";
 export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;

package/dist/pr.js

@@ -1,18 +1,18 @@
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { loadEffectiveConfig, resolveConfigString } from './config.js';
-import { syncFiles } from './file-sync.js';
-import { pathExists, promptForPathConflict } from './conflict.js';
-import { extractHooks, runHook } from './hooks.js';
-import { appendHistory } from './history.js';
-import { isHeadless } from './headless.js';
-import { maybeRunInstallPrompt } from './install-prompt.js';
-import { detectRepository, resolveWorktreePath } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { promisify } from "node:util";
+import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { pathExists, promptForPathConflict, } from "./conflict.js";
+import { syncFiles } from "./file-sync.js";
+import { isHeadless } from "./headless.js";
+import { appendHistory } from "./history.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { detectRepository, resolveWorktreePath } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
 const execFileAsync = promisify(execFile);
-const PR_OUTPUT_FILE_ENV = 'GJI_PR_OUTPUT_FILE';
+const PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 export function parsePrInput(input) {
     if (/^\d+$/.test(input))
         return input;
@@ -42,8 +42,10 @@ export function createPrCommand(dependencies = {}) {
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const branchName = `pr/${prNumber}`;
         const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
-        const rawBasePath = resolveConfigString(config, 'worktreePath');
-        const configuredBasePath = rawBasePath?.startsWith('/') || rawBasePath?.startsWith('~') ? rawBasePath : undefined;
+        const rawBasePath = resolveConfigString(config, "worktreePath");
+        const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
+            ? rawBasePath
+            : undefined;
         const worktreePath = resolveWorktreePath(repository.repoRoot, branchName, configuredBasePath);
         if (await pathExists(worktreePath)) {
             if (options.json || isHeadless()) {
@@ -58,7 +60,7 @@ export function createPrCommand(dependencies = {}) {
                 return 1;
             }
             const choice = await prompt(worktreePath);
-            if (choice === 'reuse') {
+            if (choice === "reuse") {
                 appendHistory(worktreePath, branchName).catch(() => undefined);
                 await writeOutput(worktreePath, options.stdout);
                 return 0;
@@ -92,12 +94,12 @@ export function createPrCommand(dependencies = {}) {
         await mkdir(dirname(worktreePath), { recursive: true });
         const branchAlreadyExists = await localBranchExists(repository.repoRoot, branchName);
         const worktreeArgs = branchAlreadyExists
-            ? ['worktree', 'add', worktreePath, branchName]
-            : ['worktree', 'add', '-b', branchName, worktreePath, remoteRef];
-        await execFileAsync('git', worktreeArgs, { cwd: repository.repoRoot });
+            ? ["worktree", "add", worktreePath, branchName]
+            : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
+        await execFileAsync("git", worktreeArgs, { cwd: repository.repoRoot });
         // Sync files from main worktree before afterCreate so synced files are available to install scripts.
         const syncPatterns = Array.isArray(config.syncFiles)
-            ? config.syncFiles.filter((p) => typeof p === 'string')
+            ? config.syncFiles.filter((p) => typeof p === "string")
             : [];
         for (const pattern of syncPatterns) {
             try {
@@ -109,7 +111,11 @@ export function createPrCommand(dependencies = {}) {
         }
         await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterCreate, worktreePath, { branch: branchName, path: worktreePath, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks["after-create"], worktreePath, {
+            branch: branchName,
+            path: worktreePath,
+            repo: basename(repository.repoRoot),
+        }, options.stderr);
         if (options.json) {
             options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}\n`);
         }
@@ -122,7 +128,7 @@ export function createPrCommand(dependencies = {}) {
 }
 async function localBranchExists(repoRoot, branchName) {
     try {
-        await execFileAsync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoRoot });
+        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
         return true;
     }
     catch {
@@ -133,7 +139,7 @@ export const runPrCommand = createPrCommand();
 async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
     for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
         try {
-            await execFileAsync('git', ['fetch', 'origin', `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
+            await execFileAsync("git", ["fetch", "origin", `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
             return;
         }
         catch {
@@ -143,32 +149,39 @@ async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
     throw new Error(`No pull request ref found for #${prNumber}`);
 }
 function listPullRequestSourceRefs(input, prNumber) {
-    const allForges = ['github', 'gitlab', 'bitbucket'];
+    const allForges = [
+        "github",
+        "gitlab",
+        "bitbucket",
+    ];
     const preferredForge = detectPullRequestForge(input);
-    const orderedForges = preferredForge === 'unknown'
+    const orderedForges = preferredForge === "unknown"
         ? allForges
-        : [preferredForge, ...allForges.filter((forge) => forge !== preferredForge)];
+        : [
+            preferredForge,
+            ...allForges.filter((forge) => forge !== preferredForge),
+        ];
     return orderedForges.map((forge) => sourceRefForForge(forge, prNumber));
 }
 function detectPullRequestForge(input) {
     if (/\/pull-requests\/\d+/.test(input)) {
-        return 'bitbucket';
+        return "bitbucket";
     }
     if (/\/merge_requests\/\d+/.test(input)) {
-        return 'gitlab';
+        return "gitlab";
     }
     if (/\/pull\/\d+/.test(input)) {
-        return 'github';
+        return "github";
     }
-    return 'unknown';
+    return "unknown";
 }
 function sourceRefForForge(forge, prNumber) {
     switch (forge) {
-        case 'bitbucket':
+        case "bitbucket":
             return `refs/pull-requests/${prNumber}/from`;
-        case 'github':
+        case "github":
             return `refs/pull/${prNumber}/head`;
-        case 'gitlab':
+        case "gitlab":
             return `refs/merge-requests/${prNumber}/head`;
     }
 }

package/dist/remove.d.ts

@@ -1,4 +1,4 @@
-import { type WorktreeEntry } from './repo.js';
+import { type WorktreeEntry } from "./repo.js";
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;

package/dist/remove.js

@@ -1,26 +1,27 @@
-import { basename } from 'node:path';
-import { confirm, isCancel, select } from '@clack/prompts';
-import { loadEffectiveConfig } from './config.js';
-import { extractHooks, runHook } from './hooks.js';
-import { isHeadless } from './headless.js';
-import { sortByCurrentFirst } from './repo.js';
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from './worktree-management.js';
-import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree } from './worktree-prompts.js';
-import { writeShellOutput } from './shell-handoff.js';
-const REMOVE_OUTPUT_FILE_ENV = 'GJI_REMOVE_OUTPUT_FILE';
+import { basename } from "node:path";
+import { confirm, isCancel, select } from "@clack/prompts";
+import { loadEffectiveConfig } from "./config.js";
+import { isHeadless } from "./headless.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { sortByCurrentFirst } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
+import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
+const REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 export function createRemoveCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
-    const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
+    const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ??
+        defaultConfirmForceRemoveWorktree;
     const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runRemoveCommand(options) {
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
         if (linkedWorktrees.length === 0) {
-            emitError(options, 'No linked worktrees to finish');
+            emitError(options, "No linked worktrees to finish");
             return 1;
         }
         if (!options.branch && (options.json || isHeadless())) {
-            const message = 'branch argument is required';
+            const message = "branch argument is required";
             if (options.json) {
                 emitError(options, message);
             }
@@ -29,9 +30,10 @@ export function createRemoveCommand(dependencies = {}) {
             }
             return 1;
         }
-        const selection = options.branch ?? (await promptForWorktree(sortByCurrentFirst(linkedWorktrees)));
+        const selection = options.branch ??
+            (await promptForWorktree(sortByCurrentFirst(linkedWorktrees)));
         if (!selection) {
-            options.stderr('Aborted\n');
+            options.stderr("Aborted\n");
             return 1;
         }
         const worktree = linkedWorktrees.find((entry) => entry.branch === selection || entry.path === selection);
@@ -40,7 +42,7 @@ export function createRemoveCommand(dependencies = {}) {
             return 1;
         }
         if (!options.dryRun && !options.force && (options.json || isHeadless())) {
-            const message = '--force is required';
+            const message = "--force is required";
             if (options.json) {
                 emitError(options, message);
             }
@@ -49,8 +51,10 @@ export function createRemoveCommand(dependencies = {}) {
             }
             return 1;
         }
-        if (!options.dryRun && !options.force && !(await confirmRemoval(worktree))) {
-            options.stderr('Aborted\n');
+        if (!options.dryRun &&
+            !options.force &&
+            !(await confirmRemoval(worktree))) {
+            options.stderr("Aborted\n");
             return 1;
         }
         if (options.dryRun) {
@@ -58,14 +62,20 @@ export function createRemoveCommand(dependencies = {}) {
                 options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, dryRun: true }, null, 2)}\n`);
             }
             else {
-                const desc = worktree.branch ? `branch: ${worktree.branch}` : 'detached';
+                const desc = worktree.branch
+                    ? `branch: ${worktree.branch}`
+                    : "detached";
                 options.stdout(`Would remove worktree at ${worktree.path} (${desc})\n`);
             }
             return 0;
         }
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
-        await runHook(hooks.beforeRemove, worktree.path, { branch: worktree.branch ?? undefined, path: worktree.path, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks["before-remove"], worktree.path, {
+            branch: worktree.branch ?? undefined,
+            path: worktree.path,
+            repo: basename(repository.repoRoot),
+        }, options.stderr);
         try {
             await removeWorktree(repository.repoRoot, worktree.path);
         }
@@ -73,8 +83,9 @@ export function createRemoveCommand(dependencies = {}) {
             if (!isWorktreeDirtyError(error)) {
                 throw error;
             }
-            if (!options.force && !(await confirmForceRemoveWorktree(worktree.path))) {
-                options.stderr('Aborted\n');
+            if (!options.force &&
+                !(await confirmForceRemoveWorktree(worktree.path))) {
+                options.stderr("Aborted\n");
                 return 1;
             }
             try {
@@ -93,7 +104,8 @@ export function createRemoveCommand(dependencies = {}) {
                 if (!isBranchUnmergedError(error)) {
                     throw error;
                 }
-                if (options.force || (await confirmForceDeleteBranch(worktree.branch))) {
+                if (options.force ||
+                    (await confirmForceDeleteBranch(worktree.branch))) {
                     try {
                         await forceDeleteBranch(repository.repoRoot, worktree.branch);
                     }
@@ -118,10 +130,10 @@ export function createRemoveCommand(dependencies = {}) {
 export const runRemoveCommand = createRemoveCommand();
 async function defaultPromptForWorktree(worktrees) {
     const choice = await select({
-        message: 'Choose a worktree to finish',
+        message: "Choose a worktree to finish",
         options: worktrees.map((worktree) => ({
             hint: worktree.isCurrent ? `${worktree.path} (current)` : worktree.path,
-            label: worktree.branch ?? '(detached)',
+            label: worktree.branch ?? "(detached)",
             value: worktree.path,
         })),
     });
@@ -132,8 +144,8 @@ async function defaultConfirmRemoval(worktree) {
         message: worktree.branch
             ? `Remove worktree and delete branch ${worktree.branch}?`
             : `Remove detached worktree ${worktree.path}?`,
-        active: 'Yes',
-        inactive: 'No',
+        active: "Yes",
+        inactive: "No",
         initialValue: true,
     });
     return !isCancel(choice) && choice;

package/dist/repo-registry.js

@@ -1,8 +1,8 @@
-import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
-import { GLOBAL_CONFIG_DIRECTORY } from './config.js';
-const REGISTRY_FILE_NAME = 'repos.json';
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+const REGISTRY_FILE_NAME = "repos.json";
 const MAX_REGISTRY_ENTRIES = 100;
 export function REGISTRY_FILE_PATH(home = homedir()) {
     const configDir = process.env.GJI_CONFIG_DIR;
@@ -14,7 +14,7 @@ export function REGISTRY_FILE_PATH(home = homedir()) {
 export async function loadRegistry(home = homedir()) {
     const path = REGISTRY_FILE_PATH(home);
     try {
-        const raw = await readFile(path, 'utf8');
+        const raw = await readFile(path, "utf8");
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed))
             return [];
@@ -47,7 +47,7 @@ export async function registerRepo(repoPath, home = homedir()) {
     const filtered = existing.filter((e) => e.path !== canonicalRepoPath);
     const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
     await mkdir(dirname(registryPath), { recursive: true });
-    await writeFile(registryPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+    await writeFile(registryPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 async function normalizeRegistryForWrite(entries) {
     const normalized = [];
@@ -67,12 +67,12 @@ async function normalizeRegistryForWrite(entries) {
     return normalized;
 }
 function isRegistryEntry(value) {
-    return (typeof value === 'object' &&
+    return (typeof value === "object" &&
         value !== null &&
-        'path' in value &&
-        typeof value.path === 'string' &&
-        'name' in value &&
-        typeof value.name === 'string' &&
-        'lastUsed' in value &&
-        typeof value.lastUsed === 'number');
+        "path" in value &&
+        typeof value.path === "string" &&
+        "name" in value &&
+        typeof value.name === "string" &&
+        "lastUsed" in value &&
+        typeof value.lastUsed === "number");
 }