@solaqua/gji 0.9.0 → 0.11.0

package/dist/config.js

@@ -1,16 +1,19 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, normalize, resolve, win32, } from "node:path";
 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",
     "skipInstallPrompt",
+    "syncDirs",
     "syncDefaultBranch",
     "syncFiles",
     "syncRemote",
@@ -26,6 +29,9 @@ export async function loadConfig(root) {
     return loadConfigFile(path);
 }
 export async function loadEffectiveConfig(root, home = homedir(), onWarning) {
+    return (await loadEffectiveConfigResult(root, home, onWarning)).config;
+}
+export async function loadEffectiveConfigResult(root, home = homedir(), onWarning) {
     const [globalConfig, localConfig] = await Promise.all([
         loadGlobalConfig(home),
         loadConfig(root),
@@ -36,6 +42,7 @@ export async function loadEffectiveConfig(root, home = homedir(), onWarning) {
     const perRepoConfig = isPlainObject(repos)
         ? findPerRepoConfig(repos, root, home)
         : {};
+    validateSyncDirsConfig(perRepoConfig.syncDirs);
     // Strip the internal `repos` registry from the global base before merging.
     const globalBase = { ...globalConfig.config };
     delete globalBase.repos;
@@ -76,12 +83,18 @@ export async function loadEffectiveConfig(root, home = homedir(), onWarning) {
         Object.keys(localHooks).length > 0) {
         merged.hooks = { ...globalHooks, ...perRepoHooks, ...localHooks };
     }
-    return merged;
+    return {
+        config: toEffectiveConfig(merged),
+        dependencyBootstrapExplicit: Object.hasOwn(globalBase, "dependencyBootstrap") ||
+            Object.hasOwn(perRepoConfig, "dependencyBootstrap") ||
+            Object.hasOwn(localConfig.config, "dependencyBootstrap"),
+    };
 }
 export async function loadGlobalConfig(home = homedir()) {
     return loadConfigFile(GLOBAL_CONFIG_FILE_PATH(home));
 }
 export async function saveLocalConfig(root, config) {
+    validateConfigValues(config);
     const path = join(root, CONFIG_FILE_NAME);
     await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
     return path;
@@ -96,6 +109,7 @@ export async function updateLocalConfigKey(root, key, value) {
     return nextConfig;
 }
 export async function saveGlobalConfig(config, home = homedir()) {
+    validateConfigValues(config);
     const path = GLOBAL_CONFIG_FILE_PATH(home);
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
@@ -149,10 +163,68 @@ export function resolveConfigString(config, key) {
     const value = config[key];
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+export function validateSyncDirsConfig(value) {
+    normalizeSyncDirsConfig(value);
+}
+export function normalizeDependencyBootstrap(value) {
+    if (value === undefined)
+        return;
+    if (value !== "off" &&
+        value !== "cow-then-repair" &&
+        value !== "install-only") {
+        throw new Error('dependencyBootstrap: expected "off", "cow-then-repair", or "install-only"');
+    }
+    return value;
+}
+export function normalizeSyncDirsConfig(value) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value)) {
+        throw new Error("syncDirs: expected an array of relative directory paths");
+    }
+    return value.map((pattern) => {
+        if (typeof pattern !== "string") {
+            throw new Error("syncDirs: every entry must be a string");
+        }
+        return validateSyncDirPattern(pattern);
+    });
+}
+function validateConfigValues(config) {
+    validateSyncDirsConfig(config.syncDirs);
+    normalizeDependencyBootstrap(config.dependencyBootstrap);
+    const repos = config.repos;
+    if (!isPlainObject(repos))
+        return;
+    for (const repoConfig of Object.values(repos)) {
+        if (isPlainObject(repoConfig)) {
+            validateConfigValues(repoConfig);
+        }
+    }
+}
+export function validateSyncDirPattern(pattern) {
+    if (pattern.length === 0 ||
+        isAbsolute(pattern) ||
+        win32.isAbsolute(pattern)) {
+        throw new Error(`syncDirs: pattern must be a relative path, got: ${pattern}`);
+    }
+    const segments = pattern.split(/[\\/]+/u);
+    if (segments.includes("..")) {
+        throw new Error(`syncDirs: pattern must not contain '..' segments, got: ${pattern}`);
+    }
+    if (segments.some((segment) => segment.toLowerCase() === ".git")) {
+        throw new Error(`syncDirs: pattern must not include .git, got: ${pattern}`);
+    }
+    const normalized = normalize(pattern);
+    if (normalized === ".") {
+        throw new Error(`syncDirs: pattern must name a directory below the repository root, got: ${pattern}`);
+    }
+    return normalized;
+}
 async function loadConfigFile(path) {
     try {
         const rawConfig = await readFile(path, "utf8");
         const parsedConfig = JSON.parse(rawConfig);
+        validateConfigValues(parsedConfig);
         return {
             config: mergeConfig(parsedConfig),
             exists: true,
@@ -171,10 +243,42 @@ async function loadConfigFile(path) {
     }
 }
 function mergeConfig(...values) {
-    return values.reduce((config, value) => ({
-        ...config,
-        ...value,
-    }), { ...DEFAULT_CONFIG });
+    return values.reduce((config, value) => Object.assign(config, value), { ...DEFAULT_CONFIG });
+}
+function toEffectiveConfig(config) {
+    const effective = { ...config };
+    if (config.dependencyBootstrap !== undefined) {
+        effective.dependencyBootstrap = normalizeDependencyBootstrap(config.dependencyBootstrap);
+    }
+    for (const key of [
+        "branchPrefix",
+        "dependencyBuildCommand",
+        "editor",
+        "installSaveTarget",
+        "shellIntegration",
+        "syncDefaultBranch",
+        "syncRemote",
+        "worktreePath",
+    ]) {
+        if (effective[key] !== undefined && typeof effective[key] !== "string") {
+            delete effective[key];
+        }
+    }
+    if (effective.skipInstallPrompt !== undefined &&
+        typeof effective.skipInstallPrompt !== "boolean") {
+        delete effective.skipInstallPrompt;
+    }
+    if (config.syncDirs !== undefined) {
+        effective.syncDirs = normalizeSyncDirsConfig(config.syncDirs);
+    }
+    if (Array.isArray(config.syncFiles)) {
+        effective.syncFiles = config.syncFiles.filter((value) => typeof value === "string");
+    }
+    else
+        delete effective.syncFiles;
+    if (!isPlainObject(config.hooks))
+        delete effective.hooks;
+    return effective;
 }
 function findPerRepoConfig(repos, repoRoot, home) {
     for (const [key, value] of Object.entries(repos)) {

package/dist/dependency-bootstrap-prompt.d.ts

@@ -0,0 +1,24 @@
+import { type DependencyBootstrapMode, type EffectiveGjiConfig } from "./config.js";
+import { type DependencyBootstrapCandidate } from "./dependency-bootstrap.js";
+export interface DependencyBootstrapPromptDependencies {
+    promptForDependencyBootstrap?: (candidate: DependencyBootstrapCandidate) => Promise<DependencyBootstrapMode | null>;
+    writeConfigKey?: (root: string, key: string, value: unknown) => Promise<void>;
+    writeGlobalRepoConfigKey?: (repoRoot: string, key: string, value: unknown) => Promise<void>;
+}
+export interface DependencyBootstrapPolicyResolution {
+    mode: DependencyBootstrapMode;
+    prompted: boolean;
+    source: "explicit" | "prompted" | "default" | "legacy";
+}
+export declare function resolveDependencyBootstrapPolicy(context: {
+    repoRoot: string;
+    currentRoot?: string;
+    detectionRoot?: string;
+    worktreePath: string;
+}, config: EffectiveGjiConfig, dependencyBootstrapExplicit: boolean, options: {
+    dryRun?: boolean;
+    legacyInstallPromptConfigured?: boolean;
+    nonInteractive?: boolean;
+    stderr: (chunk: string) => void;
+    dependencies?: DependencyBootstrapPromptDependencies;
+}): Promise<DependencyBootstrapPolicyResolution>;

package/dist/dependency-bootstrap-prompt.js

@@ -0,0 +1,103 @@
+import { isCancel, select } from "@clack/prompts";
+import { updateGlobalRepoConfigKey, updateLocalConfigKey, } from "./config.js";
+import { detectDependencyBootstrapCandidate, } from "./dependency-bootstrap.js";
+import { isHeadless } from "./headless.js";
+export async function resolveDependencyBootstrapPolicy(context, config, dependencyBootstrapExplicit, options) {
+    if (dependencyBootstrapExplicit) {
+        return {
+            mode: config.dependencyBootstrap ?? "off",
+            prompted: false,
+            source: "explicit",
+        };
+    }
+    if (options.dryRun || options.nonInteractive || isHeadless()) {
+        return { mode: "off", prompted: false, source: "default" };
+    }
+    if (options.legacyInstallPromptConfigured &&
+        !options.dependencies?.promptForDependencyBootstrap) {
+        return { mode: "off", prompted: false, source: "legacy" };
+    }
+    let candidate;
+    try {
+        candidate = await detectDependencyBootstrapCandidate(context);
+    }
+    catch (error) {
+        options.stderr(`gji: dependency setup detection failed: ${toErrorMessage(error)}\n`);
+        return { mode: "off", prompted: false, source: "default" };
+    }
+    if (!candidate)
+        return { mode: "off", prompted: false, source: "default" };
+    const prompt = options.dependencies?.promptForDependencyBootstrap ??
+        defaultPromptForDependencyBootstrap;
+    const choice = await prompt(candidate);
+    if (choice === null)
+        return { mode: "off", prompted: true, source: "prompted" };
+    const mode = choice;
+    await persistDependencyBootstrapPolicy(context.repoRoot, config, mode, options.dependencies, options.stderr);
+    return { mode, prompted: true, source: "prompted" };
+}
+async function persistDependencyBootstrapPolicy(repoRoot, config, mode, dependencies, stderr) {
+    const writeLocal = dependencies?.writeConfigKey ??
+        (async (root, key, value) => {
+            await updateLocalConfigKey(root, key, value);
+        });
+    const writeGlobal = dependencies?.writeGlobalRepoConfigKey ??
+        (async (root, key, value) => {
+            await updateGlobalRepoConfigKey(root, key, value);
+        });
+    try {
+        if (config.installSaveTarget === "global") {
+            await writeGlobal(repoRoot, "dependencyBootstrap", mode);
+        }
+        else {
+            await writeLocal(repoRoot, "dependencyBootstrap", mode);
+        }
+    }
+    catch (error) {
+        stderr(`gji: failed to save dependencyBootstrap: ${toErrorMessage(error)}\n`);
+    }
+}
+async function defaultPromptForDependencyBootstrap(candidate) {
+    const reuseHint = formatReuseHint(candidate);
+    const subject = candidate.kind === "build-cache"
+        ? "dependencies and build state"
+        : "dependencies";
+    const choice = await select({
+        message: `Set up ${candidate.adapter} ${subject} for new worktrees? (${candidate.lockfile})`,
+        options: [
+            {
+                value: "cow-then-repair",
+                label: "Reuse and repair (recommended)",
+                hint: reuseHint,
+            },
+            {
+                value: "install-only",
+                label: "Install fresh each time",
+                hint: candidate.repairCommand,
+            },
+            {
+                value: "off",
+                label: "Skip dependency setup",
+                hint: "leave dependencies to project hooks or manual setup",
+            },
+        ],
+    });
+    if (isCancel(choice))
+        return null;
+    return choice;
+}
+function formatReuseHint(candidate) {
+    if (candidate.adapter === "pnpm") {
+        return "reuse local node_modules through CoW, then run pnpm install --frozen-lockfile";
+    }
+    if (candidate.adapter === "npm") {
+        return "npm uses a clean install because node_modules is not seeded";
+    }
+    if (!candidate.seedable) {
+        return `repair ${candidate.target} with ${candidate.repairCommand}`;
+    }
+    return `reuse ${candidate.target} through CoW, then run ${candidate.repairCommand}`;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/dependency-bootstrap.d.ts

@@ -0,0 +1,129 @@
+import { type CloneFailureStore } from "./clone-failure-store.js";
+import { type CommandRunner } from "./command-runner.js";
+import type { DependencyBootstrapMode } from "./config.js";
+import { type CloneDirectory } from "./dir-clone.js";
+export type BootstrapKind = "dependency" | "build-cache" | "sync-file";
+export type BootstrapState = "seeded" | "repaired" | "installed" | "fallback" | "skipped" | "failed";
+export type BootstrapStrategy = "cow-then-repair" | "repair-only" | "install-only";
+export type BootstrapCommandRunner = CommandRunner;
+export interface BootstrapPreparationContext {
+    detectionRoot?: string;
+    sourceRoot: string;
+    worktreePath: string;
+}
+export interface BootstrapExecutionContext {
+    runCommand: BootstrapCommandRunner;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export interface BootstrapTarget {
+    adapter: string;
+    kind: BootstrapKind;
+    relativePath: string;
+    sourceRoot: string;
+    worktreePath: string;
+    sourcePath: string;
+    targetPath: string;
+    repairCommand: string;
+    repairState: "repaired" | "installed";
+    existingBeforeBootstrap: boolean;
+}
+export type BootstrapTargetOwnership = "adapter" | "syncDirs" | "empty" | "preserve";
+export interface BootstrapRepairFailureContext {
+    target: BootstrapTarget;
+    ownership: BootstrapTargetOwnership;
+    targetExistedBeforeRepair: boolean;
+}
+export interface BootstrapOutputMetadata {
+    adapter: string;
+    kind: BootstrapKind;
+    target: string;
+    repairCommand: string;
+}
+export interface BootstrapAdapter {
+    readonly kind: BootstrapKind;
+    readonly lockfile: string;
+    readonly name: string;
+    readonly relativePath: string;
+    detect(context: BootstrapPreparationContext): Promise<BootstrapTarget | null>;
+    seedPath(target: BootstrapTarget): string;
+    repair(target: BootstrapTarget, context: BootstrapExecutionContext): Promise<void>;
+    canSeed(target: BootstrapTarget): Promise<boolean>;
+    output(target: BootstrapTarget): BootstrapOutputMetadata;
+    shouldRetryAfterRepairFailure(context: BootstrapRepairFailureContext): boolean;
+    cleanupAfterRepairFailure(context: BootstrapRepairFailureContext): Promise<void>;
+}
+export interface DependencyBootstrapPlan {
+    mode: DependencyBootstrapMode;
+    targets: readonly PlannedBootstrapTarget[];
+}
+export interface PlannedBootstrapTarget {
+    adapter: BootstrapAdapter;
+    target: BootstrapTarget;
+    seedable: boolean;
+}
+export interface BootstrapEvent {
+    adapter: string;
+    kind: BootstrapKind;
+    reason?: string;
+    state: BootstrapState;
+    target: string;
+    message: string;
+}
+export interface DependencyBootstrapReporter {
+    readonly measureCloneSize: boolean;
+    dependency(event: BootstrapEvent): void;
+}
+export interface DependencyBootstrapReport {
+    mode: DependencyBootstrapMode;
+    ready: boolean;
+    events: readonly BootstrapEvent[];
+}
+export interface DependencyBootstrapDependencies {
+    cloneDirectory?: CloneDirectory;
+    failureStore?: CloneFailureStore;
+    runCommand?: BootstrapCommandRunner;
+    stderr?: (chunk: string) => void;
+    stdout?: (chunk: string) => void;
+    seededDirectories?: readonly string[];
+}
+export interface DependencyBootstrapPreview {
+    mode: DependencyBootstrapMode;
+    targets: readonly {
+        adapter: string;
+        kind: BootstrapKind;
+        target: string;
+        repairCommand: string;
+        seedable: boolean;
+        strategy: BootstrapStrategy;
+    }[];
+}
+export interface DependencyBootstrapCandidate {
+    adapter: string;
+    kind: BootstrapKind;
+    lockfile: string;
+    target: string;
+    repairCommand: string;
+    seedable: boolean;
+}
+export declare function prepareDependencyBootstrap(mode: DependencyBootstrapMode, context: {
+    repoRoot: string;
+    currentRoot?: string;
+    detectionRoot?: string;
+    worktreePath: string;
+    checkUvRuntime?: (target: BootstrapTarget) => Promise<boolean>;
+    cargoBuildCommand?: string;
+}): Promise<DependencyBootstrapPlan>;
+export declare function detectDependencyBootstrapCandidate(context: {
+    repoRoot: string;
+    currentRoot?: string;
+    detectionRoot?: string;
+    worktreePath: string;
+    checkUvRuntime?: (target: BootstrapTarget) => Promise<boolean>;
+    cargoBuildCommand?: string;
+}): Promise<DependencyBootstrapCandidate | null>;
+export declare function previewDependencyBootstrap(plan: DependencyBootstrapPlan): DependencyBootstrapPreview;
+export declare function executeDependencyBootstrap(plan: DependencyBootstrapPlan, options: DependencyBootstrapDependencies & {
+    repoRoot: string;
+    reporter: DependencyBootstrapReporter;
+}): Promise<DependencyBootstrapReport>;