@solaqua/gji 0.12.4 → 0.13.0

package/dist/{cli.js → cli/program.js}

@@ -1,33 +1,32 @@
-import { createRequire } from "node:module";
 import { Command } from "commander";
 import updateNotifier from "update-notifier";
-import { runBackCommand } from "./back.js";
-import { runCleanCommand } from "./clean.js";
-import { runCompletionCommand } from "./completion.js";
-import { runConfigCommand } from "./config-command.js";
-import { runDoctorCommand } from "./doctor.js";
-import { runDoneCommand } from "./done.js";
-import { runGoCommand } from "./go.js";
-import { isHeadless } from "./headless.js";
-import { runHistoryCommand } from "./history-command.js";
-import { runHubCommand } from "./hub.js";
-import { runInitCommand } from "./init.js";
-import { runLsCommand } from "./ls.js";
-import { runNewCommand } from "./new.js";
-import { runOpenCommand } from "./open.js";
-import { runPrCommand } from "./pr.js";
-import { createPrOpenCommand, } from "./pr-open.js";
-import { runRemoveCommand } from "./remove.js";
-import { detectRepository } from "./repo.js";
-import { registerRepo } from "./repo-registry.js";
-import { runRootCommand } from "./root.js";
-import { runHookCommand } from "./run-hook.js";
-import { runStatusCommand } from "./status.js";
-import { runSyncCommand } from "./sync.js";
-import { runSyncFilesCommand } from "./sync-files-command.js";
-import { runTaskCommand } from "./task-command.js";
-import { runUndoCommand } from "./undo.js";
-import { runWarpCommand } from "./warp.js";
+import packageJson from "../../package.json" with { type: "json" };
+import { runBackCommand } from "./commands/back.js";
+import { runCleanCommand } from "./commands/clean.js";
+import { runCompletionCommand } from "./commands/completion.js";
+import { runConfigCommand } from "./commands/config-command.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { runDoneCommand } from "./commands/done.js";
+import { runGoCommand } from "./commands/go.js";
+import { runHistoryCommand } from "./commands/history-command.js";
+import { runHubCommand } from "./commands/hub.js";
+import { runInitCommand } from "./commands/init.js";
+import { runLsCommand } from "./commands/ls.js";
+import { runNewCommand } from "./commands/new.js";
+import { runOpenCommand } from "./commands/open.js";
+import { runPrCommand } from "./commands/pr.js";
+import { createPrOpenCommand, } from "./commands/pr-open.js";
+import { runRemoveCommand } from "./commands/remove.js";
+import { runRootCommand } from "./commands/root.js";
+import { runHookCommand } from "./commands/run-hook.js";
+import { runStatusCommand } from "./commands/status.js";
+import { runSyncCommand } from "./commands/sync.js";
+import { runSyncFilesCommand } from "./commands/sync-files-command.js";
+import { runTaskCommand } from "./commands/task-command.js";
+import { runUndoCommand } from "./commands/undo.js";
+import { runWarpCommand } from "./commands/warp.js";
+import { createCliDependencies } from "./dependencies.js";
+import { isHeadless } from "./runtime/headless.js";
 export function createProgram() {
     const program = new Command();
     const packageMetadata = readPackageMetadata();
@@ -40,14 +39,13 @@ export function createProgram() {
     registerCommands(program);
     program.addHelpText("after", "\nCommon workflows:\n" +
         "  gji new <branch>       create a worktree\n" +
+        "  gji new --branch-only <branch>  reuse the current worktree\n" +
         "  gji go <branch>        navigate to a worktree\n" +
         "  gji go                 choose; press Tab for all repositories\n" +
         "  gji go -               return to the previous worktree\n");
     return program;
 }
 function readPackageMetadata() {
-    const require = createRequire(import.meta.url);
-    const packageJson = require("../package.json");
     return {
         name: typeof packageJson.name === "string" ? packageJson.name : "gji",
         version: typeof packageJson.version === "string" ? packageJson.version : "0.0.0",
@@ -58,8 +56,9 @@ export async function runCli(argv, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const stdout = options.stdout ?? (() => undefined);
     const stderr = options.stderr ?? (() => undefined);
+    const dependencies = options.dependencies ?? createCliDependencies();
     if (shouldRegisterCurrentRepo(argv) || isHubInvocation(argv)) {
-        await maybeRegisterCurrentRepo(cwd);
+        await maybeRegisterCurrentRepo(cwd, dependencies);
     }
     const program = createProgram();
     program.configureOutput({
@@ -75,12 +74,14 @@ export async function runCli(argv, options = {}) {
             now: options.now,
             stderr,
             stdout,
+            runtime: dependencies,
         }, options.hubDependencies);
         return { exitCode };
     }
     try {
         attachCommandActions(program, {
             cwd,
+            dependencies,
             prOpenDependencies: options.prOpenDependencies,
             stderr,
             stdout,
@@ -143,10 +144,10 @@ function shouldRegisterCurrentRepo(argv) {
 function isHubInvocation(argv) {
     return argv.length === 0 || (argv.length === 1 && argv[0] === "--json");
 }
-async function maybeRegisterCurrentRepo(cwd) {
+async function maybeRegisterCurrentRepo(cwd, dependencies) {
     try {
-        const { repoRoot } = await detectRepository(cwd);
-        await registerRepo(repoRoot);
+        const { repoRoot } = await dependencies.repositoryContext.detectRepository(cwd);
+        await dependencies.registry.registerRepo(repoRoot);
     }
     catch {
         // Registration is best effort; command behaviour should not depend on it.
@@ -155,7 +156,8 @@ async function maybeRegisterCurrentRepo(cwd) {
 function registerCommands(program) {
     program
         .command("new [branch]")
-        .description("create a new branch or detached linked worktree")
+        .description("create a branch with an optional linked worktree")
+        .option("--branch-only", "update the default branch and create the new branch in the current worktree")
         .option("-f, --force", "remove and recreate the worktree if the target path already exists")
         .option("--detached", "create a detached worktree without a branch")
         .option("--from-current", "base the new branch on the current worktree instead of the main worktree (cannot be combined with --detached)")
@@ -335,12 +337,11 @@ function registerCommands(program) {
         .action(notImplemented("config unset"));
 }
 function attachCommandActions(program, options) {
-    program.commands
-        .find((command) => command.name() === "new")
-        ?.action(async (branch, commandOptions) => {
+    requireCommand(program, "new").action(async (branch, commandOptions) => {
         const exitCode = await runNewCommand({
             ...options,
             branch,
+            branchOnly: commandOptions.branchOnly,
             copy: commandOptions.copy,
             detached: commandOptions.detached,
             dryRun: commandOptions.dryRun,
@@ -353,73 +354,68 @@ function attachCommandActions(program, options) {
             open: commandOptions.open,
             take: commandOptions.take,
             task: commandOptions.task,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "done")
-        ?.action(async (branch, commandOptions) => {
+    requireCommand(program, "done").action(async (branch, commandOptions) => {
         const exitCode = await runDoneCommand({
             branch,
             cwd: options.cwd,
             force: commandOptions.force,
             json: commandOptions.json,
             keepBranch: commandOptions.keepBranch,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
         if (exitCode !== 0)
             throw commanderExit(exitCode);
     });
-    program.commands
-        .find((command) => command.name() === "undo")
-        ?.action(async (id, commandOptions) => {
+    requireCommand(program, "undo").action(async (id, commandOptions) => {
         const exitCode = await runUndoCommand({
             cwd: options.cwd,
             id,
             json: commandOptions.json,
             list: commandOptions.list,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
         if (exitCode !== 0)
             throw commanderExit(exitCode);
     });
-    program.commands
-        .find((command) => command.name() === "init")
-        ?.action(async (shell, commandOptions) => {
+    requireCommand(program, "init").action(async (shell, commandOptions) => {
         const exitCode = await runInitCommand({
             cwd: options.cwd,
             json: commandOptions.json,
             shell,
             stderr: options.stderr,
             stdout: options.stdout,
+            runtime: options.dependencies,
             write: commandOptions.write,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "doctor")
-        ?.action(async (commandOptions) => {
+    requireCommand(program, "doctor").action(async (commandOptions) => {
         const exitCode = await runDoctorCommand({
             cwd: options.cwd,
             fix: commandOptions.fix,
             json: commandOptions.json,
             stderr: options.stderr,
             stdout: options.stdout,
+            runtime: options.dependencies,
             yes: commandOptions.yes,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "completion")
-        ?.action(async (shell) => {
+    requireCommand(program, "completion").action(async (shell) => {
         const exitCode = await runCompletionCommand({
             shell,
             stderr: options.stderr,
@@ -429,9 +425,7 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "pr")
-        ?.action(async (number, commandOptions) => {
+    requireCommand(program, "pr").action(async (number, commandOptions) => {
         const exitCode = await runPrCommand({
             cwd: options.cwd,
             dryRun: commandOptions.dryRun,
@@ -440,30 +434,28 @@ function attachCommandActions(program, options) {
             number,
             stderr: options.stderr,
             stdout: options.stdout,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    const prOpenCommand = program.commands
-        .find((command) => command.name() === "pr")
-        ?.commands.find((command) => command.name() === "open");
+    const prOpenCommand = requireCommand(requireCommand(program, "pr"), "open");
     const runPrOpenCommand = createPrOpenCommand(options.prOpenDependencies);
-    prOpenCommand?.action(async (target, commandOptions) => {
+    prOpenCommand.action(async (target, commandOptions) => {
         const exitCode = await runPrOpenCommand({
             cwd: options.cwd,
             stderr: options.stderr,
             stdout: options.stdout,
             select: commandOptions.select,
             target,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "back")
-        ?.action(async (n, commandOptions) => {
+    requireCommand(program, "back").action(async (n, commandOptions) => {
         if (n !== undefined && !/^\d+$/.test(n)) {
             options.stderr(`gji back: invalid step count: ${n}\n`);
             throw commanderExit(1);
@@ -473,6 +465,7 @@ function attachCommandActions(program, options) {
             cwd: options.cwd,
             n: steps,
             print: commandOptions.print,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -480,27 +473,25 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "history")
-        ?.action(async (commandOptions) => {
+    requireCommand(program, "history").action(async (commandOptions) => {
         const exitCode = await runHistoryCommand({
             cwd: options.cwd,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stdout: options.stdout,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "open")
-        ?.action(async (branch, commandOptions) => {
+    requireCommand(program, "open").action(async (branch, commandOptions) => {
         const exitCode = await runOpenCommand({
             branch,
             cwd: options.cwd,
             editor: commandOptions.editor,
             save: commandOptions.save,
             select: commandOptions.select,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
             workspace: commandOptions.workspace,
@@ -509,9 +500,7 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "go")
-        ?.action(async (branch, commandOptions) => {
+    requireCommand(program, "go").action(async (branch, commandOptions) => {
         const exitCode = await runGoCommand({
             branch,
             cwd: options.cwd,
@@ -521,56 +510,53 @@ function attachCommandActions(program, options) {
             root: commandOptions.root,
             stderr: options.stderr,
             stdout: options.stdout,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "root")
-        ?.action(async (commandOptions) => {
+    requireCommand(program, "root").action(async (commandOptions) => {
         const exitCode = await runRootCommand({
             cwd: options.cwd,
             print: commandOptions.print,
+            runtime: options.dependencies,
             stdout: options.stdout,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "status")
-        ?.action(async (commandOptions) => {
+    requireCommand(program, "status").action(async (commandOptions) => {
         const exitCode = await runStatusCommand({
             cwd: options.cwd,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stdout: options.stdout,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "task")
-        ?.action(async (task, commandOptions) => {
+    requireCommand(program, "task").action(async (task, commandOptions) => {
         const exitCode = await runTaskCommand({
             clear: commandOptions.clear,
             cwd: options.cwd,
             json: commandOptions.json,
             stderr: options.stderr,
+            runtime: options.dependencies,
             task,
             stdout: options.stdout,
         });
         if (exitCode !== 0)
             throw commanderExit(exitCode);
     });
-    program.commands
-        .find((command) => command.name() === "sync")
-        ?.action(async (commandOptions) => {
+    requireCommand(program, "sync").action(async (commandOptions) => {
         const exitCode = await runSyncCommand({
             all: commandOptions.all,
             cwd: options.cwd,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -578,12 +564,13 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    const syncFilesCommand = program.commands.find((command) => command.name() === "sync-files");
-    syncFilesCommand?.action(async (commandOptions) => {
+    const syncFilesCommand = requireCommand(program, "sync-files");
+    syncFilesCommand.action(async (commandOptions) => {
         const exitCode = await runSyncFilesCommand({
             action: "list",
             cwd: options.cwd,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -591,13 +578,12 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    syncFilesCommand?.commands
-        .find((command) => command.name() === "list")
-        ?.action(async (commandOptions) => {
+    requireCommand(syncFilesCommand, "list").action(async (commandOptions) => {
         const exitCode = await runSyncFilesCommand({
             action: "list",
             cwd: options.cwd,
-            json: commandOptions.json || syncFilesCommand?.opts().json,
+            json: commandOptions.json || syncFilesCommand.opts().json,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -605,14 +591,13 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    syncFilesCommand?.commands
-        .find((command) => command.name() === "add")
-        ?.action(async (paths, commandOptions) => {
+    requireCommand(syncFilesCommand, "add").action(async (paths, commandOptions) => {
         const exitCode = await runSyncFilesCommand({
             action: "add",
             cwd: options.cwd,
-            json: commandOptions.json || syncFilesCommand?.opts().json,
+            json: commandOptions.json || syncFilesCommand.opts().json,
             paths,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -624,8 +609,9 @@ function attachCommandActions(program, options) {
         const exitCode = await runSyncFilesCommand({
             action: "remove",
             cwd: options.cwd,
-            json: commandOptions.json || syncFilesCommand?.opts().json,
+            json: commandOptions.json || syncFilesCommand.opts().json,
             paths,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -633,31 +619,27 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     };
-    syncFilesCommand?.commands
-        .find((command) => command.name() === "remove")
-        ?.action(runSyncFilesRemoveCommand);
-    program.commands
-        .find((command) => command.name() === "ls")
-        ?.action(async (commandOptions) => {
+    requireCommand(syncFilesCommand, "remove").action(runSyncFilesRemoveCommand);
+    requireCommand(program, "ls").action(async (commandOptions) => {
         const exitCode = await runLsCommand({
             compact: commandOptions.compact,
             cwd: options.cwd,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stdout: options.stdout,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "clean")
-        ?.action(async (commandOptions) => {
+    requireCommand(program, "clean").action(async (commandOptions) => {
         const exitCode = await runCleanCommand({
             cwd: options.cwd,
             dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
             stale: commandOptions.stale,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -672,6 +654,7 @@ function attachCommandActions(program, options) {
             dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -679,29 +662,24 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     };
-    program.commands
-        .find((command) => command.name() === "remove")
-        ?.action(async (branch, commandOptions) => {
+    requireCommand(program, "remove").action(async (branch, commandOptions) => {
         if (!commandOptions.json) {
             options.stderr("gji remove is deprecated; use 'gji done' for one worktree or 'gji clean' for bulk cleanup.\n");
         }
         return runRemovalCommand(branch, commandOptions);
     });
-    program.commands
-        .find((command) => command.name() === "run-hook")
-        ?.action(async (hook) => {
+    requireCommand(program, "run-hook").action(async (hook) => {
         const exitCode = await runHookCommand({
             cwd: options.cwd,
             hook,
+            runtime: options.dependencies,
             stderr: options.stderr,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    program.commands
-        .find((command) => command.name() === "warp")
-        ?.action(async (branch, commandOptions) => {
+    requireCommand(program, "warp").action(async (branch, commandOptions) => {
         if (!commandOptions.json) {
             options.stderr("gji warp is deprecated; use 'gji go' (press Tab for all repositories).\n");
         }
@@ -709,6 +687,7 @@ function attachCommandActions(program, options) {
             branch,
             cwd: options.cwd,
             json: commandOptions.json,
+            runtime: options.dependencies,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -716,58 +695,63 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
-    const configCommand = program.commands.find((command) => command.name() === "config");
-    configCommand?.action(async () => {
+    const configCommand = requireCommand(program, "config");
+    configCommand.action(async () => {
         const exitCode = await runConfigCommand({
             cwd: options.cwd,
             stdout: options.stdout,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    configCommand?.commands
-        .find((command) => command.name() === "get")
-        ?.action(async (key) => {
+    requireCommand(configCommand, "get").action(async (key) => {
         const exitCode = await runConfigCommand({
             action: "get",
             cwd: options.cwd,
             key,
             stdout: options.stdout,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    configCommand?.commands
-        .find((command) => command.name() === "set")
-        ?.action(async (key, value) => {
+    requireCommand(configCommand, "set").action(async (key, value) => {
         const exitCode = await runConfigCommand({
             action: "set",
             cwd: options.cwd,
             key,
             stderr: options.stderr,
             stdout: options.stdout,
+            runtime: options.dependencies,
             value,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
-    configCommand?.commands
-        .find((command) => command.name() === "unset")
-        ?.action(async (key) => {
+    requireCommand(configCommand, "unset").action(async (key) => {
         const exitCode = await runConfigCommand({
             action: "unset",
             cwd: options.cwd,
             key,
             stdout: options.stdout,
+            runtime: options.dependencies,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
 }
+function requireCommand(parent, name) {
+    const command = parent.commands.find((candidate) => candidate.name() === name);
+    if (command === undefined) {
+        throw new Error(`Command registration is missing: ${name}`);
+    }
+    return command;
+}
 function notImplemented(commandName) {
     return () => {
         throw new Error(`'${commandName}' is not implemented yet.`);

package/dist/domain/repository/context.d.ts

@@ -0,0 +1,6 @@
+export interface RepositoryContext {
+    currentRoot: string;
+    isWorktree: boolean;
+    repoName: string;
+    repoRoot: string;
+}

package/dist/domain/repository/context.js

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

package/dist/domain/repository/registry.d.ts

@@ -0,0 +1,5 @@
+export interface RepoRegistryEntry {
+    lastUsed: number;
+    name: string;
+    path: string;
+}

package/dist/domain/repository/registry.js

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

package/dist/domain/shared/concurrency.d.ts

@@ -0,0 +1 @@
+export declare function mapWithConcurrency<Input, Output>(items: readonly Input[], limit: number, mapper: (item: Input) => Promise<Output>): Promise<Output[]>;

package/dist/domain/shared/concurrency.js

@@ -0,0 +1,15 @@
+export async function mapWithConcurrency(items, limit, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function readNext() {
+        for (;;) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= items.length)
+                return;
+            results[index] = await mapper(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
+    return results;
+}

package/dist/domain/worktree/matching.d.ts

@@ -0,0 +1,4 @@
+import type { WorktreeSource } from "./source.js";
+export declare function resolveWorktreeQuery(sources: WorktreeSource[], query: string): WorktreeSource | null;
+export declare function resolveWorktreeQueryMatches(sources: WorktreeSource[], query: string): WorktreeSource[];
+export declare function resolveExactWorktreeQueryMatches(sources: WorktreeSource[], query: string): WorktreeSource[];