@solaqua/gji 0.12.4 → 0.13.0

package/dist/infrastructure/worktree/info.js

@@ -0,0 +1,61 @@
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+import { readWorktreeHealth } from "../git/health.js";
+import { readBranchLastCommitTimestamp } from "../git/refs.js";
+import { getWorktreeSlot } from "../persistence/slots.js";
+import { readTask } from "../persistence/task.js";
+const MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
+export async function readWorktreeInfos(worktrees) {
+    return mapWithConcurrency(worktrees, MAX_WORKTREE_INFO_READ_CONCURRENCY, readWorktreeInfo);
+}
+export async function readWorktreeInfo(worktree) {
+    const [healthResult, lastCommitResult, slotResult, taskResult] = await Promise.allSettled([
+        readWorktreeHealth(worktree.path),
+        worktree.branch === null
+            ? null
+            : readBranchLastCommitTimestamp(worktree.path, worktree.branch),
+        getWorktreeSlot(worktree.path),
+        readTask(worktree.path),
+    ]);
+    const health = healthResult.status === "fulfilled" ? healthResult.value : null;
+    const lastCommitTimestamp = lastCommitResult.status === "fulfilled" ? lastCommitResult.value : null;
+    const slot = slotResult.status === "fulfilled" ? slotResult.value : null;
+    const task = taskResult.status === "fulfilled" ? (taskResult.value?.task ?? null) : null;
+    return {
+        ...worktree,
+        lastCommitTimestamp,
+        slot,
+        status: health?.status ?? "unknown",
+        task,
+        upstream: buildUpstreamState(worktree.branch, health),
+    };
+}
+function buildUpstreamState(branch, health) {
+    if (branch === null) {
+        return { kind: "detached" };
+    }
+    if (health === null) {
+        return { kind: "unknown" };
+    }
+    if (!health.hasUpstream) {
+        return { kind: "no-upstream" };
+    }
+    if (health.upstreamGone) {
+        return { kind: "stale" };
+    }
+    return {
+        ahead: health.ahead,
+        behind: health.behind,
+        kind: "tracked",
+    };
+}
+export function serializeWorktreeInfo(info) {
+    return {
+        branch: info.branch,
+        lastCommitTimestamp: info.lastCommitTimestamp,
+        path: info.path,
+        slot: info.slot,
+        status: info.status,
+        task: info.task,
+        upstream: info.upstream,
+    };
+}

package/dist/{worktree-management.d.ts → infrastructure/worktree/lifecycle.d.ts}

@@ -1,9 +1,3 @@
-import { type RepositoryContext, type WorktreeEntry } from "./repo.js";
-export interface LinkedWorktreeContext {
-    linkedWorktrees: WorktreeEntry[];
-    repository: RepositoryContext;
-}
-export declare function loadLinkedWorktrees(cwd: string): Promise<LinkedWorktreeContext>;
 export declare function removeWorktree(repoRoot: string, worktreePath: string): Promise<void>;
 export declare function forceRemoveWorktree(repoRoot: string, worktreePath: string): Promise<void>;
 export declare function deleteBranch(repoRoot: string, branch: string): Promise<void>;

package/dist/{worktree-management.js → infrastructure/worktree/lifecycle.js}

@@ -1,18 +1,10 @@
 import { execFile } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { promisify } from "node:util";
-import { detectRepository, listWorktrees, } from "./repo.js";
+import { listWorktrees } from "../repository/worktrees.js";
 const execFileAsync = promisify(execFile);
 // Force English output so error message string matching is locale-independent.
 const GIT_ENV = { ...process.env, LC_ALL: "C" };
-export async function loadLinkedWorktrees(cwd) {
-    const repository = await detectRepository(cwd);
-    const linkedWorktrees = (await listWorktrees(cwd)).filter((worktree) => worktree.path !== repository.repoRoot);
-    return {
-        linkedWorktrees,
-        repository,
-    };
-}
 export async function removeWorktree(repoRoot, worktreePath) {
     await execFileAsync("git", ["worktree", "remove", worktreePath], {
         cwd: repoRoot,

package/dist/ports/bootstrap.d.ts

@@ -0,0 +1,61 @@
+import type { EffectiveGjiConfig } from "./config.js";
+import type { CommandRunner } from "./process.js";
+export type BootstrapKind = "dependency" | "build-cache" | "sync-file";
+export type BootstrapState = "installed" | "failed";
+export type DependencyBootstrapMode = "off" | "install";
+export interface BootstrapEvent {
+    adapter: string;
+    kind: BootstrapKind;
+    reason?: string;
+    state: BootstrapState;
+    target: string;
+    message: string;
+}
+export interface DependencyBootstrapReporter {
+    dependency(event: BootstrapEvent): void;
+}
+export interface DependencyBootstrapReport {
+    mode: DependencyBootstrapMode;
+    ready: boolean;
+    events: readonly BootstrapEvent[];
+}
+export interface DependencyBootstrapPreview {
+    mode: DependencyBootstrapMode;
+    targets: readonly {
+        adapter: string;
+        kind: BootstrapKind;
+        target: string;
+        command: string;
+    }[];
+}
+export interface DependencyBootstrapPreviewContext {
+    repoRoot: string;
+    currentRoot?: string;
+    worktreePath: string;
+    cargoBuildCommand?: string;
+}
+export interface DependencyBootstrapPort {
+    resolveMode(dependencyBootstrap: "off" | undefined, noInstall?: boolean): DependencyBootstrapMode;
+    preview(mode: DependencyBootstrapMode, context: DependencyBootstrapPreviewContext): Promise<DependencyBootstrapPreview>;
+}
+export interface WorktreeBootstrapOptions {
+    branch: string;
+    config: EffectiveGjiConfig;
+    currentRoot?: string;
+    dependencyDetectionRoot?: string;
+    dependencyMode: DependencyBootstrapMode;
+    runCommand?: CommandRunner;
+    commandStdout?: (chunk: string) => void;
+    commandStderr?: (chunk: string) => void;
+    repoRoot: string;
+    reporter: DependencyBootstrapReporter;
+    worktreePath: string;
+}
+export interface WorktreeBootstrapResult {
+    dependencyBootstrap: DependencyBootstrapReport;
+    ready: boolean;
+    syncFileFailures: readonly BootstrapEvent[];
+}
+export interface WorktreeBootstrapPort {
+    bootstrapWorktree(options: WorktreeBootstrapOptions): Promise<WorktreeBootstrapResult>;
+}

package/dist/ports/bootstrap.js

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

package/dist/ports/config.d.ts

@@ -0,0 +1,21 @@
+export type GjiConfig = Record<string, unknown>;
+export type DependencyBootstrapSetting = "off";
+export declare const KNOWN_CONFIG_KEYS: ReadonlySet<string>;
+export declare const KNOWN_GLOBAL_CONFIG_KEYS: ReadonlySet<string>;
+export interface EffectiveGjiConfig extends GjiConfig {
+    branchPrefix?: string;
+    dependencyBuildCommand?: string;
+    dependencyBootstrap?: DependencyBootstrapSetting;
+    editor?: string;
+    hooks?: Record<string, unknown>;
+    installSaveTarget?: string;
+    shellIntegration?: string;
+    syncFiles?: readonly string[];
+    syncDefaultBranch?: string;
+    syncRemote?: string;
+    worktreePath?: string;
+}
+export interface ConfigPort {
+    loadEffectiveConfig(root: string, home?: string, onWarning?: (message: string) => void): Promise<EffectiveGjiConfig>;
+    resolveConfigString(config: GjiConfig, key: string): string | undefined;
+}

package/dist/ports/config.js

@@ -0,0 +1,17 @@
+export const KNOWN_CONFIG_KEYS = new Set([
+    "branchPrefix",
+    "dependencyBuildCommand",
+    "dependencyBootstrap",
+    "editor",
+    "hooks",
+    "installSaveTarget",
+    "shellIntegration",
+    "syncDefaultBranch",
+    "syncFiles",
+    "syncRemote",
+    "worktreePath",
+]);
+export const KNOWN_GLOBAL_CONFIG_KEYS = new Set([
+    ...KNOWN_CONFIG_KEYS,
+    "repos",
+]);

package/dist/ports/editor.d.ts

@@ -0,0 +1,6 @@
+export interface EditorDefinition {
+    cli: string;
+    name: string;
+    newWindowFlag?: string;
+    supportsWorkspace: boolean;
+}

package/dist/ports/editor.js

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

package/dist/ports/git.d.ts

@@ -0,0 +1,8 @@
+export interface RemoteBase {
+    branch: string;
+    ref: string;
+}
+export interface GitCommandPort {
+    runGit(cwd: string, args: string[]): Promise<string>;
+    runGitRaw(cwd: string, args: string[]): Promise<string>;
+}

package/dist/ports/git.js

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

package/dist/ports/history.d.ts

@@ -0,0 +1,5 @@
+export interface HistoryEntry {
+    branch: string | null;
+    path: string;
+    timestamp: number;
+}

package/dist/ports/history.js

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

package/dist/ports/hooks.d.ts

@@ -0,0 +1,12 @@
+export type GjiHookCommand = string | string[];
+export interface GjiHooks {
+    "after-create"?: GjiHookCommand;
+    "after-enter"?: GjiHookCommand;
+    "before-remove"?: GjiHookCommand;
+}
+export interface HookContext {
+    branch?: string;
+    path: string;
+    repo: string;
+    slot?: number | null;
+}

package/dist/ports/hooks.js

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

package/dist/{command-runner.d.ts → ports/process.d.ts}

@@ -3,4 +3,3 @@ export interface CommandRunnerOptions {
     env?: NodeJS.ProcessEnv;
     shell?: boolean;
 }
-export declare const runCommand: CommandRunner;

package/dist/ports/process.js

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

package/dist/ports/pull-requests.d.ts

@@ -0,0 +1,11 @@
+export interface PullRequestInfo {
+    number: number;
+    sourceBranch: string;
+    title?: string;
+    url: string;
+}
+export interface PullRequestPort {
+    findOpenPullRequest(repoRoot: string, number: number): Promise<PullRequestInfo | null>;
+    listOpenPullRequests(repoRoot: string, sourceBranch: string): Promise<PullRequestInfo[]>;
+    listOpenPullRequestsForRepository(repoRoot: string): Promise<PullRequestInfo[]>;
+}

package/dist/ports/pull-requests.js

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

package/dist/ports/repository.d.ts

@@ -0,0 +1,17 @@
+import type { RepositoryContext } from "../domain/repository/context.js";
+import type { RepoRegistryEntry } from "../domain/repository/registry.js";
+import type { WorktreeEntry } from "../domain/worktree/types.js";
+export interface RepositoryContextPort {
+    detectRepository(cwd: string): Promise<RepositoryContext>;
+}
+export interface WorktreePort {
+    listWorktrees(cwd: string): Promise<WorktreeEntry[]>;
+}
+export interface RepositoryRefPort {
+    getRepositoryRemoteUrl(repoRoot: string, remote: string): Promise<string | null>;
+    hasLocalBranch(repoRoot: string, branch: string): Promise<boolean>;
+    hasRemoteBranch(repoRoot: string, remote: string, branch: string): Promise<boolean>;
+}
+export interface RepositoryRegistryPort {
+    loadRegistry(): Promise<RepoRegistryEntry[]>;
+}

package/dist/ports/repository.js

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

package/dist/{bootstrap-output.d.ts → presentation/bootstrap/output.d.ts}

@@ -1,4 +1,4 @@
-import type { DependencyBootstrapReporter } from "./dependency-bootstrap.js";
+import type { DependencyBootstrapReporter } from "../../ports/bootstrap.js";
 export declare function createBootstrapReporter(write: (chunk: string) => void, json: boolean): DependencyBootstrapReporter & {
     write: (chunk: string) => void;
 };

package/dist/presentation/bootstrap/preview.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyBootstrapPreview } from "../../ports/bootstrap.js";
+export declare function formatDependencyBootstrapPreview(preview: DependencyBootstrapPreview | undefined): string;

package/dist/{bootstrap-preview.js → presentation/bootstrap/preview.js}

@@ -1,7 +1,3 @@
-import { prepareDependencyBootstrap, previewDependencyBootstrap, } from "./dependency-bootstrap.js";
-export async function createDependencyBootstrapPreview(mode, context) {
-    return previewDependencyBootstrap(await prepareDependencyBootstrap(mode, context));
-}
 export function formatDependencyBootstrapPreview(preview) {
     if (!preview)
         return "";

package/dist/{shell-completion.js → presentation/shell/completion.js}

@@ -1,8 +1,8 @@
-import { KNOWN_GLOBAL_CONFIG_KEYS } from "./config.js";
+import { KNOWN_GLOBAL_CONFIG_KEYS } from "../../ports/config.js";
 const TOP_LEVEL_COMMANDS = [
     {
         name: "new",
-        description: "create a new branch or detached linked worktree",
+        description: "create a branch with an optional linked worktree",
     },
     {
         name: "done",
@@ -149,7 +149,7 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-				COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --task --force --open --editor --dry-run --no-install --json --help" -- "$cur") )
+				COMPREPLY=( $(compgen -W "--branch-only --detached --from-current --no-fetch --take --copy --task --force --open --editor --dry-run --no-install --json --help" -- "$cur") )
       ;;
     done)
       COMPREPLY=( $(compgen -W "--force --keep-branch --json --help" -- "$cur") )
@@ -387,6 +387,7 @@ complete -c gji -n '__fish_seen_subcommand_from undo' -l json -d 'emit JSON on s
 ${commandLines}
 
 complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
+complete -c gji -n '__fish_seen_subcommand_from new' -l branch-only -d 'update the default branch and create the new branch in the current worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l from-current -d 'base the new branch on the current worktree instead of the main worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l take -d 'move current uncommitted changes into the new worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l copy -d 'copy current uncommitted changes instead of moving them (requires --take)'
@@ -553,7 +554,7 @@ fi
 
 case "\${words[2]}" in
   new)
-    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--no-fetch[skip refreshing the remote default branch before creating the new branch]' '--take[move current uncommitted changes into the new worktree]' '--copy[copy current uncommitted changes instead of moving them (requires --take)]' '--task[record the purpose of the new worktree]:description:' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--no-install[skip automatic dependency setup in the new worktree]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _arguments '--branch-only[update the default branch and create the new branch in the current worktree]' '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--no-fetch[skip refreshing the remote default branch before creating the new branch]' '--take[move current uncommitted changes into the new worktree]' '--copy[copy current uncommitted changes instead of moving them (requires --take)]' '--task[record the purpose of the new worktree]:description:' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--no-install[skip automatic dependency setup in the new worktree]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
     ;;
   done)
     _arguments '--force[remove dirty or unmerged worktrees without prompting]' '--keep-branch[remove the worktree but preserve its branch]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '

package/dist/presentation/terminal/context-card.d.ts

@@ -0,0 +1,2 @@
+import type { ContextCardModel } from "../../application/worktree/context-card.js";
+export declare function renderContextCard(model: ContextCardModel): string;

package/dist/{context-card.js → presentation/terminal/context-card.js}

@@ -1,16 +1,7 @@
-import { listWorktrees } from "./repo.js";
-import { readTask } from "./task.js";
-import { readWorktreeInfo } from "./worktree-info.js";
-export async function renderContextCard(worktreePath) {
-    const worktree = (await listWorktrees(worktreePath)).find((entry) => entry.path === worktreePath);
-    if (!worktree)
-        return null;
-    const info = await readWorktreeInfo(worktree);
-    const task = await readTask(worktreePath);
-    if (!task)
-        return null;
+export function renderContextCard(model) {
+    const { info, task } = model;
     const rows = [`┌ ${info.branch ?? "(detached)"}`];
-    rows.push(`│ task   ${task.task}`);
+    rows.push(`│ task   ${task}`);
     rows.push(`│ state  ${formatState(info)}`);
     if (info.lastCommitTimestamp !== null)
         rows.push(`│ last   ${formatLastCommit(info)}`);

package/dist/presentation/worktree/format.d.ts

@@ -0,0 +1,4 @@
+import type { UpstreamState } from "../../application/worktree/read-models.js";
+export declare function formatUpstreamState(upstream: UpstreamState): string;
+export declare function formatLastCommit(timestampSeconds: number | null): string;
+export declare function formatRelativeAge(timestampSeconds: number, nowSeconds?: number): string;

package/dist/presentation/worktree/format.js

@@ -0,0 +1,41 @@
+export function formatUpstreamState(upstream) {
+    if (upstream.kind === "detached")
+        return "n/a";
+    if (upstream.kind === "no-upstream")
+        return "no-upstream";
+    if (upstream.kind === "stale")
+        return "gone";
+    if (upstream.kind === "unknown")
+        return "unknown";
+    return formatAheadBehind(upstream.ahead, upstream.behind);
+}
+function formatAheadBehind(ahead, behind) {
+    if (ahead === 0 && behind === 0)
+        return "up to date";
+    if (ahead === 0)
+        return `behind ${behind}`;
+    if (behind === 0)
+        return `ahead ${ahead}`;
+    return `ahead ${ahead}, behind ${behind}`;
+}
+export function formatLastCommit(timestampSeconds) {
+    return timestampSeconds === null
+        ? "n/a"
+        : formatRelativeAge(timestampSeconds);
+}
+export function formatRelativeAge(timestampSeconds, nowSeconds = Math.floor(Date.now() / 1000)) {
+    const ageSeconds = Math.max(0, nowSeconds - timestampSeconds);
+    const units = [
+        { label: "y", seconds: 365 * 24 * 60 * 60 },
+        { label: "mo", seconds: 30 * 24 * 60 * 60 },
+        { label: "d", seconds: 24 * 60 * 60 },
+        { label: "h", seconds: 60 * 60 },
+        { label: "m", seconds: 60 },
+    ];
+    for (const unit of units) {
+        const value = Math.floor(ageSeconds / unit.seconds);
+        if (value > 0)
+            return `${value}${unit.label} ago`;
+    }
+    return "just now";
+}

package/dist/{worktree-picker.d.ts → presentation/worktree/picker.d.ts}

@@ -1,7 +1,8 @@
 import type { Readable, Writable } from "node:stream";
-import { type PullRequestInfo } from "./pull-requests.js";
-import type { WorktreeEntry } from "./repo.js";
-import type { WorktreeSource } from "./worktree-source.js";
+import { type WorktreeCatalogDependencies, type WorktreeMetadataMode } from "../../application/worktree/catalog.js";
+import type { WorktreeSource } from "../../domain/worktree/source.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+import type { PullRequestInfo, PullRequestPort } from "../../ports/pull-requests.js";
 export type WorktreePromptSource = WorktreeSource;
 export interface WorktreePromptEntry extends WorktreeEntry {
     group: "recent" | "other";
@@ -11,14 +12,12 @@ export interface WorktreePromptEntry extends WorktreeEntry {
     repoName: string;
     task?: string | null;
 }
-export type QueryWorktreePullRequests = (repoRoot: string, sourceBranch: string) => Promise<PullRequestInfo[]>;
-export type QueryRepositoryPullRequests = (repoRoot: string) => Promise<PullRequestInfo[]>;
+export type QueryWorktreePullRequests = PullRequestPort["listOpenPullRequests"];
+export type QueryRepositoryPullRequests = PullRequestPort["listOpenPullRequestsForRepository"];
 export interface BuildWorktreePromptEntriesDependencies {
     metadata?: WorktreeMetadataMode;
-    queryPullRequests?: QueryWorktreePullRequests;
-    queryRepositoryPullRequests?: QueryRepositoryPullRequests;
+    catalog?: WorktreeCatalogDependencies;
 }
-export type WorktreeMetadataMode = "full" | "fast";
 export interface WorktreePickerIO {
     input?: Readable & {
         isTTY?: boolean;
@@ -40,9 +39,6 @@ export interface WorktreePromptScopeResult {
     toggleLabel: string;
 }
 export declare function buildWorktreePromptEntries(sources: WorktreeSource[], dependencies?: BuildWorktreePromptEntriesDependencies): Promise<WorktreePromptEntry[]>;
-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[];
 export declare function promptForSingleWorktree(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO & {
     scope?: WorktreePromptScope;
 }): Promise<string | null>;