@solaqua/gji 0.12.4 → 0.13.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { homedir } from "node:os";
-import { runCli } from "./cli.js";
-import { loadGlobalConfig } from "./config.js";
-import { isHeadless } from "./headless.js";
+import { runCli } from "./cli/program.js";
+import { isHeadless } from "./cli/runtime/headless.js";
+import { loadGlobalConfig } from "./infrastructure/persistence/config.js";
 async function main() {
     try {
         const argv = process.argv.slice(2);

package/dist/{dependency-bootstrap.d.ts → infrastructure/bootstrap/dependency-bootstrap.d.ts}

@@ -1,8 +1,7 @@
-import { type CommandRunner } from "./command-runner.js";
-export type BootstrapKind = "dependency" | "build-cache" | "sync-file";
-export type BootstrapState = "installed" | "failed";
-export type DependencyBootstrapMode = "off" | "install";
+import type { BootstrapKind, DependencyBootstrapMode, DependencyBootstrapPreview, DependencyBootstrapReport, DependencyBootstrapReporter } from "../../ports/bootstrap.js";
+import type { CommandRunner } from "../../ports/process.js";
 export type BootstrapCommandRunner = CommandRunner;
+export type { BootstrapEvent, BootstrapKind, DependencyBootstrapMode, DependencyBootstrapPreview, DependencyBootstrapReport, DependencyBootstrapReporter, } from "../../ports/bootstrap.js";
 export declare function resolveDependencyBootstrapMode(dependencyBootstrap: "off" | undefined, noInstall?: boolean): DependencyBootstrapMode;
 export interface BootstrapPreparationContext {
     detectionRoot?: string;
@@ -44,36 +43,11 @@ export interface PlannedBootstrapTarget {
     adapter: BootstrapAdapter;
     target: BootstrapTarget;
 }
-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 DependencyBootstrapDependencies {
     runCommand?: BootstrapCommandRunner;
     stderr?: (chunk: string) => void;
     stdout?: (chunk: string) => void;
 }
-export interface DependencyBootstrapPreview {
-    mode: DependencyBootstrapMode;
-    targets: readonly {
-        adapter: string;
-        kind: BootstrapKind;
-        target: string;
-        command: string;
-    }[];
-}
 export declare function prepareDependencyBootstrap(mode: DependencyBootstrapMode, context: {
     repoRoot: string;
     currentRoot?: string;
@@ -85,4 +59,3 @@ export declare function previewDependencyBootstrap(plan: DependencyBootstrapPlan
 export declare function executeDependencyBootstrap(plan: DependencyBootstrapPlan, options: DependencyBootstrapDependencies & {
     reporter: DependencyBootstrapReporter;
 }): Promise<DependencyBootstrapReport>;
-export {};

package/dist/{dependency-bootstrap.js → infrastructure/bootstrap/dependency-bootstrap.js}

@@ -1,9 +1,9 @@
 import { readFile, realpath } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
-import { runCommand } from "./command-runner.js";
-import { pathExists } from "./fs-utils.js";
-import { inspectDestination } from "./safe-destination.js";
-import { validateUvInstallation, validateUvStructure, } from "./uv-validation.js";
+import { pathExists } from "../filesystem/fs-utils.js";
+import { inspectDestination } from "../filesystem/safe-destination.js";
+import { runCommand } from "../process/command-runner.js";
+import { validateUvInstallation, validateUvStructure, } from "../validation/uv.js";
 export function resolveDependencyBootstrapMode(dependencyBootstrap, noInstall = false) {
     if (noInstall || dependencyBootstrap === "off")
         return "off";

package/dist/infrastructure/git/health.d.ts

@@ -0,0 +1,9 @@
+export interface WorktreeHealth {
+    ahead: number;
+    behind: number;
+    hasUpstream: boolean;
+    upstreamGone: boolean;
+    status: "clean" | "dirty";
+}
+export declare function readWorktreeHealth(cwd: string): Promise<WorktreeHealth>;
+export declare function isDirtyWorktree(cwd: string): Promise<boolean>;

package/dist/infrastructure/git/health.js

@@ -0,0 +1,44 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function readWorktreeHealth(cwd) {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain=v2", "--branch"], { cwd });
+    return parseWorktreeHealth(stdout);
+}
+export async function isDirtyWorktree(cwd) {
+    const health = await readWorktreeHealth(cwd);
+    return health.status === "dirty";
+}
+function parseWorktreeHealth(output) {
+    let ahead = 0;
+    let behind = 0;
+    let hasUpstream = false;
+    let hasAb = false;
+    let dirty = false;
+    for (const line of output.split("\n").filter(Boolean)) {
+        if (line.startsWith("# branch.upstream ")) {
+            hasUpstream = true;
+            continue;
+        }
+        if (line.startsWith("# branch.ab ")) {
+            const match = /^# branch\.ab \+(\d+) -(\d+)$/.exec(line);
+            if (!match) {
+                throw new Error(`Unexpected branch.ab output: '${line}'`);
+            }
+            hasAb = true;
+            ahead = Number(match[1]);
+            behind = Number(match[2]);
+            continue;
+        }
+        if (!line.startsWith("# ")) {
+            dirty = true;
+        }
+    }
+    return {
+        ahead,
+        behind,
+        hasUpstream,
+        upstreamGone: hasUpstream && !hasAb,
+        status: dirty ? "dirty" : "clean",
+    };
+}

package/dist/infrastructure/git/refs.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteBase } from "../../ports/git.js";
+export type { RemoteBase } from "../../ports/git.js";
+export declare function isBranchMergedInto(cwd: string, branch: string, base?: string): Promise<boolean>;
+export declare function resolveRemoteDefaultBranch(cwd: string, remote: string): Promise<string | null>;
+export declare function resolveRemoteBase(cwd: string, remote: string, configuredBranch?: string): Promise<RemoteBase | null>;
+export declare function readBranchLastCommitTimestamp(cwd: string, branch: string): Promise<number | null>;

package/dist/{git.js → infrastructure/git/refs.js}

@@ -1,24 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { runGit } from "./runner.js";
 const execFileAsync = promisify(execFile);
-export async function runGit(cwd, args) {
-    try {
-        const { stdout } = await execFileAsync("git", args, { cwd });
-        return stdout.trim();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Git command failed in '${cwd}': ${message}`);
-    }
-}
-export async function readWorktreeHealth(cwd) {
-    const { stdout } = await execFileAsync("git", ["status", "--porcelain=v2", "--branch"], { cwd });
-    return parseWorktreeHealth(stdout);
-}
-export async function isDirtyWorktree(cwd) {
-    const health = await readWorktreeHealth(cwd);
-    return health.status === "dirty";
-}
 export async function isBranchMergedInto(cwd, branch, base = "HEAD") {
     try {
         await execFileAsync("git", ["merge-base", "--is-ancestor", branch, base], {
@@ -104,39 +87,6 @@ export async function readBranchLastCommitTimestamp(cwd, branch) {
         return null;
     }
 }
-function parseWorktreeHealth(output) {
-    let ahead = 0;
-    let behind = 0;
-    let hasUpstream = false;
-    let hasAb = false;
-    let dirty = false;
-    for (const line of output.split("\n").filter(Boolean)) {
-        if (line.startsWith("# branch.upstream ")) {
-            hasUpstream = true;
-            continue;
-        }
-        if (line.startsWith("# branch.ab ")) {
-            const match = /^# branch\.ab \+(\d+) -(\d+)$/.exec(line);
-            if (!match) {
-                throw new Error(`Unexpected branch.ab output: '${line}'`);
-            }
-            hasAb = true;
-            ahead = Number(match[1]);
-            behind = Number(match[2]);
-            continue;
-        }
-        if (!line.startsWith("# ")) {
-            dirty = true;
-        }
-    }
-    return {
-        ahead,
-        behind,
-        hasUpstream,
-        upstreamGone: hasUpstream && !hasAb,
-        status: dirty ? "dirty" : "clean",
-    };
-}
 function hasExitCode(error, code) {
     return (error instanceof Error &&
         "code" in error &&

package/dist/infrastructure/git/runner.d.ts

@@ -0,0 +1,2 @@
+export declare function runGit(cwd: string, args: string[]): Promise<string>;
+export declare function runGitRaw(cwd: string, args: string[]): Promise<string>;

package/dist/infrastructure/git/runner.js

@@ -0,0 +1,16 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function runGit(cwd, args) {
+    return (await runGitRaw(cwd, args)).trim();
+}
+export async function runGitRaw(cwd, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd });
+        return stdout;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Git command failed in '${cwd}': ${message}`);
+    }
+}

package/dist/{editor.d.ts → infrastructure/integrations/editor.d.ts}

@@ -1,8 +1,4 @@
-export interface EditorDefinition {
-    cli: string;
-    name: string;
-    newWindowFlag?: string;
-    supportsWorkspace: boolean;
-}
+import type { EditorDefinition } from "../../ports/editor.js";
+export type { EditorDefinition } from "../../ports/editor.js";
 export declare const EDITORS: EditorDefinition[];
 export declare function defaultSpawnEditor(cli: string, args: string[]): Promise<void>;

package/dist/{pull-requests.d.ts → infrastructure/integrations/pull-requests.d.ts}

@@ -1,10 +1,6 @@
+import type { PullRequestPort } from "../../ports/pull-requests.js";
 export type PullRequestForge = "bitbucket" | "github" | "gitlab";
-export interface PullRequestInfo {
-    number: number;
-    sourceBranch: string;
-    title?: string;
-    url: string;
-}
+export type { PullRequestInfo } from "../../ports/pull-requests.js";
 export interface PullRequestRemote {
     forge: PullRequestForge;
     host: string;
@@ -25,10 +21,6 @@ export interface PullRequestQueryDependencies {
     fetch?: typeof fetch;
     runCommand?: PullRequestCommandRunner;
 }
-export interface PullRequestQuery {
-    findOpenPullRequest: (repoRoot: string, number: number) => Promise<PullRequestInfo | null>;
-    listOpenPullRequests: (repoRoot: string, sourceBranch: string) => Promise<PullRequestInfo[]>;
-    listOpenPullRequestsForRepository: (repoRoot: string) => Promise<PullRequestInfo[]>;
-}
+export type PullRequestQuery = PullRequestPort;
 export declare function parsePullRequestRemote(remoteUrl: string): PullRequestRemote | null;
 export declare function createPullRequestQuery(dependencies?: PullRequestQueryDependencies): PullRequestQuery;

package/dist/{config.d.ts → infrastructure/persistence/config.d.ts}

@@ -1,23 +1,9 @@
+import type { DependencyBootstrapSetting, EffectiveGjiConfig, GjiConfig } from "../../ports/config.js";
+export type { DependencyBootstrapSetting, EffectiveGjiConfig, GjiConfig, } from "../../ports/config.js";
+export { KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, } from "../../ports/config.js";
 export declare const CONFIG_FILE_NAME = ".gji.json";
 export declare const GLOBAL_CONFIG_DIRECTORY = ".config/gji";
 export declare const GLOBAL_CONFIG_NAME = "config.json";
-export declare const KNOWN_CONFIG_KEYS: ReadonlySet<string>;
-export declare const KNOWN_GLOBAL_CONFIG_KEYS: ReadonlySet<string>;
-export type GjiConfig = Record<string, unknown>;
-export type DependencyBootstrapSetting = "off";
-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 LoadedConfig {
     config: GjiConfig;
     exists: boolean;

package/dist/{config.js → infrastructure/persistence/config.js}

@@ -1,26 +1,11 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, } from "../../ports/config.js";
+export { KNOWN_CONFIG_KEYS, KNOWN_GLOBAL_CONFIG_KEYS, } from "../../ports/config.js";
 export const CONFIG_FILE_NAME = ".gji.json";
 export const GLOBAL_CONFIG_DIRECTORY = ".config/gji";
 export const GLOBAL_CONFIG_NAME = "config.json";
-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",
-]);
 const REMOVED_CONFIG_KEYS = new Set(["syncDirs"]);
 export const DEFAULT_CONFIG = Object.freeze({});
 export async function loadConfig(root) {

package/dist/{history.d.ts → infrastructure/persistence/history.d.ts}

@@ -1,9 +1,6 @@
+import type { HistoryEntry } from "../../ports/history.js";
+export type { HistoryEntry } from "../../ports/history.js";
 export declare const HISTORY_FILE_NAME = "history.json";
-export interface HistoryEntry {
-    branch: string | null;
-    path: string;
-    timestamp: number;
-}
 export declare function HISTORY_FILE_PATH(home?: string): string;
 export declare function loadHistory(home?: string): Promise<HistoryEntry[]>;
 export declare function appendHistory(path: string, branch: string | null, home?: string): Promise<void>;

package/dist/{task.js → infrastructure/persistence/task.js}

@@ -1,6 +1,6 @@
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { worktreeGitDir } from "./repo.js";
+import { worktreeGitDir } from "../repository/context.js";
 export async function readTask(worktreePath) {
     try {
         const parsed = JSON.parse(await readFile(await taskPath(worktreePath), "utf8"));

package/dist/infrastructure/process/command-runner.d.ts

@@ -0,0 +1,3 @@
+import type { CommandRunner } from "../../ports/process.js";
+export type { CommandRunner, CommandRunnerOptions, } from "../../ports/process.js";
+export declare const runCommand: CommandRunner;

package/dist/{hooks.d.ts → infrastructure/process/hooks.d.ts}

@@ -1,15 +1,5 @@
-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;
-}
+import type { GjiHookCommand, GjiHooks, HookContext } from "../../ports/hooks.js";
+export type { GjiHookCommand, GjiHooks, HookContext, } from "../../ports/hooks.js";
 export declare function runHook(hookCmd: GjiHookCommand | undefined, cwd: string, context: HookContext, stderr: (chunk: string) => void, stdout?: (chunk: string) => void): Promise<void>;
 export declare function interpolate(template: string, context: HookContext): string;
 export declare function extractHooks(config: Record<string, unknown>): GjiHooks;

package/dist/infrastructure/repository/adapters.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigPort } from "../../ports/config.js";
+import type { RepositoryContextPort, RepositoryRefPort, RepositoryRegistryPort, WorktreePort } from "../../ports/repository.js";
+export declare const configPort: ConfigPort;
+export declare const repositoryContextPort: RepositoryContextPort;
+export declare const worktreePort: WorktreePort;
+export declare const repositoryRefPort: RepositoryRefPort;
+export declare const repositoryRegistryPort: RepositoryRegistryPort;

package/dist/infrastructure/repository/adapters.js

@@ -0,0 +1,23 @@
+import { loadEffectiveConfig, resolveConfigString, } from "../persistence/config.js";
+import { detectRepository } from "./context.js";
+import { getRepositoryRemoteUrl, hasLocalBranch, hasRemoteBranch, } from "./refs.js";
+import { loadRegistry } from "./registry.js";
+import { listWorktrees } from "./worktrees.js";
+export const configPort = {
+    loadEffectiveConfig,
+    resolveConfigString,
+};
+export const repositoryContextPort = {
+    detectRepository,
+};
+export const worktreePort = {
+    listWorktrees,
+};
+export const repositoryRefPort = {
+    getRepositoryRemoteUrl,
+    hasLocalBranch,
+    hasRemoteBranch,
+};
+export const repositoryRegistryPort = {
+    loadRegistry,
+};

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

@@ -0,0 +1,3 @@
+import type { RepositoryContext } from "../../domain/repository/context.js";
+export declare function detectRepository(cwd: string): Promise<RepositoryContext>;
+export declare function worktreeGitDir(worktreePath: string): Promise<string>;

package/dist/infrastructure/repository/context.js

@@ -0,0 +1,20 @@
+import { basename, dirname, isAbsolute, resolve } from "node:path";
+import { runGit } from "../git/runner.js";
+export async function detectRepository(cwd) {
+    const currentRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    const rawCommonDir = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
+    const gitCommonDir = isAbsolute(rawCommonDir)
+        ? rawCommonDir
+        : resolve(currentRoot, rawCommonDir);
+    const repoRoot = dirname(gitCommonDir);
+    return {
+        currentRoot,
+        isWorktree: currentRoot !== repoRoot,
+        repoName: basename(repoRoot),
+        repoRoot,
+    };
+}
+export async function worktreeGitDir(worktreePath) {
+    const rawGitDir = await runGit(worktreePath, ["rev-parse", "--git-dir"]);
+    return isAbsolute(rawGitDir) ? rawGitDir : resolve(worktreePath, rawGitDir);
+}

package/dist/infrastructure/repository/refs.d.ts

@@ -0,0 +1,3 @@
+export declare function hasLocalBranch(repoRoot: string, branch: string): Promise<boolean>;
+export declare function hasRemoteBranch(repoRoot: string, remote: string, branch: string): Promise<boolean>;
+export declare function getRepositoryRemoteUrl(repoRoot: string, remote: string): Promise<string | null>;

package/dist/infrastructure/repository/refs.js

@@ -0,0 +1,37 @@
+import { runGit } from "../git/runner.js";
+export async function hasLocalBranch(repoRoot, branch) {
+    try {
+        await runGit(repoRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/heads/${branch}`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function hasRemoteBranch(repoRoot, remote, branch) {
+    try {
+        await runGit(repoRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/remotes/${remote}/${branch}`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getRepositoryRemoteUrl(repoRoot, remote) {
+    try {
+        return await runGit(repoRoot, ["remote", "get-url", remote]);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/{repo-registry.d.ts → infrastructure/repository/registry.d.ts}

@@ -1,8 +1,4 @@
-export interface RepoRegistryEntry {
-    lastUsed: number;
-    name: string;
-    path: string;
-}
+import type { RepoRegistryEntry } from "../../domain/repository/registry.js";
 export interface RegistryRemovalResult {
     removedPaths: string[];
     skippedPaths: string[];

package/dist/{repo-registry.js → infrastructure/repository/registry.js}

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { access, mkdir, readFile, realpath, rename, rm, 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";
+import { GLOBAL_CONFIG_DIRECTORY } from "../persistence/config.js";
 const REGISTRY_FILE_NAME = "repos.json";
 const MAX_REGISTRY_ENTRIES = 100;
 const registryLocks = new Map();

package/dist/infrastructure/repository/worktrees.d.ts

@@ -0,0 +1,2 @@
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+export declare function listWorktrees(cwd: string): Promise<WorktreeEntry[]>;

package/dist/infrastructure/repository/worktrees.js

@@ -0,0 +1,48 @@
+import { access } from "node:fs/promises";
+import { runGit } from "../git/runner.js";
+export async function listWorktrees(cwd) {
+    const [output, currentRoot] = await Promise.all([
+        runGit(cwd, ["worktree", "list", "--porcelain"]),
+        runGit(cwd, ["rev-parse", "--show-toplevel"]),
+    ]);
+    const entries = output.split("\n\n").filter(Boolean);
+    const worktrees = entries.flatMap((entry) => {
+        if (findOptionalPorcelainValue(entry, "prunable") !== null)
+            return [];
+        const path = findPorcelainValue(entry, "worktree");
+        const branchRef = findOptionalPorcelainValue(entry, "branch");
+        return [
+            {
+                branch: branchRef ? branchRef.replace("refs/heads/", "") : null,
+                isCurrent: path === currentRoot,
+                path,
+            },
+        ];
+    });
+    const accessible = await Promise.all(worktrees.map(async (worktree) => {
+        try {
+            await access(worktree.path);
+            return worktree;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return accessible.filter((worktree) => worktree !== null);
+}
+function findPorcelainValue(block, key) {
+    const value = findOptionalPorcelainValue(block, key);
+    if (!value) {
+        throw new Error(`Missing '${key}' in git worktree output.`);
+    }
+    return value;
+}
+function findOptionalPorcelainValue(block, key) {
+    const line = block
+        .split("\n")
+        .find((candidate) => candidate.startsWith(`${key} `));
+    if (!line) {
+        return null;
+    }
+    return line.slice(key.length + 1);
+}

package/dist/{uv-validation.d.ts → infrastructure/validation/uv.d.ts}

@@ -1,4 +1,4 @@
-import type { BootstrapExecutionContext, BootstrapTarget } from "./dependency-bootstrap.js";
+import type { BootstrapExecutionContext, BootstrapTarget } from "../bootstrap/dependency-bootstrap.js";
 export declare function validateUvRelocation(target: BootstrapTarget, context: BootstrapExecutionContext): Promise<void>;
 export declare function validateUvInstallation(target: BootstrapTarget, context: BootstrapExecutionContext): Promise<void>;
 export declare function validateUvStructure(target: BootstrapTarget, context: BootstrapExecutionContext): Promise<void>;

package/dist/{uv-validation.js → infrastructure/validation/uv.js}

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { lstat, open, readdir, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { promisify, TextDecoder } from "node:util";
-import { isNotFoundError } from "./fs-utils.js";
+import { isNotFoundError } from "../filesystem/fs-utils.js";
 const execFileAsync = promisify(execFile);
 const UV_VALIDATION_MAX_ENTRIES = 10_000;
 const UV_VALIDATION_MAX_FILE_BYTES = 1024 * 1024;

package/dist/infrastructure/worktree/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import type { WorktreeBootstrapOptions, WorktreeBootstrapResult } from "../../ports/bootstrap.js";
+export type { WorktreeBootstrapOptions, WorktreeBootstrapResult, } from "../../ports/bootstrap.js";
+export declare function bootstrapWorktree(options: WorktreeBootstrapOptions): Promise<WorktreeBootstrapResult>;

package/dist/{worktree-bootstrap.js → infrastructure/worktree/bootstrap.js}

@@ -1,8 +1,8 @@
 import { basename } from "node:path";
-import { executeDependencyBootstrap, prepareDependencyBootstrap, } from "./dependency-bootstrap.js";
-import { syncFiles } from "./file-sync.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { assignWorktreeSlot } from "./slots.js";
+import { executeDependencyBootstrap, prepareDependencyBootstrap, } from "../bootstrap/dependency-bootstrap.js";
+import { syncFiles } from "../filesystem/file-sync.js";
+import { assignWorktreeSlot } from "../persistence/slots.js";
+import { extractHooks, runHook } from "../process/hooks.js";
 export async function bootstrapWorktree(options) {
     const dependencyMode = options.dependencyMode;
     const dependencyPlan = await prepareDependencyBootstrap(dependencyMode, {
@@ -19,8 +19,7 @@ export async function bootstrapWorktree(options) {
         }
         catch (error) {
             const message = `failed to sync file "${pattern}": ${toErrorMessage(error)}`;
-            if (!options.json)
-                options.reporter.write(`Warning: ${message}\n`);
+            options.commandStderr?.(`Warning: ${message}\n`);
             syncFileFailures.push({
                 adapter: "syncFiles",
                 kind: "sync-file",
@@ -39,7 +38,7 @@ export async function bootstrapWorktree(options) {
         ? { mode: dependencyMode, ready: false, events: [] }
         : await executeDependencyBootstrap(dependencyPlan, {
             reporter: options.reporter,
-            stderr: options.commandStderr ?? options.reporter.write,
+            stderr: options.commandStderr,
             stdout: options.commandStdout,
             runCommand: options.runCommand,
         });
@@ -57,9 +56,7 @@ export async function bootstrapWorktree(options) {
         path: options.worktreePath,
         repo: basename(options.repoRoot),
         slot,
-    }, options.reporter.write, options.json
-        ? () => undefined
-        : (options.commandStdout ?? ((chunk) => process.stdout.write(chunk))));
+    }, options.commandStderr ?? (() => undefined), options.commandStdout ?? (() => undefined));
     return {
         dependencyBootstrap,
         ready: true,

package/dist/infrastructure/worktree/info.d.ts

@@ -0,0 +1,6 @@
+import type { SerializedWorktreeInfo, UpstreamState, WorktreeInfo } from "../../application/worktree/read-models.js";
+import type { WorktreeEntry } from "../../domain/worktree/types.js";
+export type { SerializedWorktreeInfo, UpstreamState, WorktreeInfo };
+export declare function readWorktreeInfos(worktrees: WorktreeEntry[]): Promise<WorktreeInfo[]>;
+export declare function readWorktreeInfo(worktree: WorktreeEntry): Promise<WorktreeInfo>;
+export declare function serializeWorktreeInfo(info: WorktreeInfo): SerializedWorktreeInfo;