@solaqua/gji 0.6.1 → 0.7.0

package/dist/completion.js

@@ -1,9 +1,9 @@
-import { renderShellCompletion } from './shell-completion.js';
-import { resolveSupportedShell } from './shell.js';
+import { resolveSupportedShell } from "./shell.js";
+import { renderShellCompletion } from "./shell-completion.js";
 export async function runCompletionCommand(options) {
     const shell = resolveSupportedShell(options.shell, process.env.SHELL);
     if (!shell) {
-        options.stderr?.('Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n');
+        options.stderr?.("Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n");
         return 1;
     }
     options.stdout(renderShellCompletion(shell));

package/dist/config-command.js

@@ -1,4 +1,4 @@
-import { loadGlobalConfig, parseConfigValue, unsetGlobalConfigKey, updateGlobalConfigKey, } from './config.js';
+import { loadGlobalConfig, parseConfigValue, unsetGlobalConfigKey, updateGlobalConfigKey, } from "./config.js";
 export async function runConfigCommand(options) {
     switch (options.action) {
         case undefined: {
@@ -6,25 +6,25 @@ export async function runConfigCommand(options) {
             writeJson(options.stdout, loaded.config);
             return 0;
         }
-        case 'get': {
+        case "get": {
             const loaded = await loadGlobalConfig();
             writeJson(options.stdout, options.key ? loaded.config[options.key] : loaded.config);
             return 0;
         }
-        case 'set':
+        case "set":
             if (options.key && options.value !== undefined) {
                 await updateGlobalConfigKey(options.key, parseConfigValue(options.value));
                 return 0;
             }
             break;
-        case 'unset':
+        case "unset":
             if (options.key) {
                 await unsetGlobalConfigKey(options.key);
                 return 0;
             }
             break;
     }
-    throw new Error(`Invalid config arguments: ${[options.action, options.key, options.value].filter(Boolean).join(' ')}`);
+    throw new Error(`Invalid config arguments: ${[options.action, options.key, options.value].filter(Boolean).join(" ")}`);
 }
 function writeJson(stdout, value) {
     stdout(`${JSON.stringify(value, null, 2)}\n`);

package/dist/config.js

@@ -1,24 +1,24 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-export const CONFIG_FILE_NAME = '.gji.json';
-export const GLOBAL_CONFIG_DIRECTORY = '.config/gji';
-export const GLOBAL_CONFIG_NAME = 'config.json';
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } 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',
-    'editor',
-    'hooks',
-    'installSaveTarget',
-    'shellIntegration',
-    'skipInstallPrompt',
-    'syncDefaultBranch',
-    'syncFiles',
-    'syncRemote',
-    'worktreePath',
+    "branchPrefix",
+    "editor",
+    "hooks",
+    "installSaveTarget",
+    "shellIntegration",
+    "skipInstallPrompt",
+    "syncDefaultBranch",
+    "syncFiles",
+    "syncRemote",
+    "worktreePath",
 ]);
 export const KNOWN_GLOBAL_CONFIG_KEYS = new Set([
     ...KNOWN_CONFIG_KEYS,
-    'repos',
+    "repos",
 ]);
 export const DEFAULT_CONFIG = Object.freeze({});
 export async function loadConfig(root) {
@@ -55,18 +55,22 @@ export async function loadEffectiveConfig(root, home = homedir(), onWarning) {
     // Warn about relative worktreePath: it must be absolute or tilde-prefixed.
     const worktreePathValue = merged.worktreePath;
     if (onWarning &&
-        typeof worktreePathValue === 'string' &&
+        typeof worktreePathValue === "string" &&
         worktreePathValue.length > 0 &&
-        !worktreePathValue.startsWith('/') &&
-        !worktreePathValue.startsWith('~')) {
+        !worktreePathValue.startsWith("/") &&
+        !worktreePathValue.startsWith("~")) {
         onWarning(`gji: "worktreePath" must be an absolute path or start with ~, got "${worktreePathValue}" — using default\n`);
     }
     // Hooks are spread across all three layers so that different hook keys from
     // different layers both apply (e.g. global afterEnter + local afterCreate).
     // Within each key the higher-precedence layer wins (same spread order).
     const globalHooks = isPlainObject(globalBase.hooks) ? globalBase.hooks : {};
-    const perRepoHooks = isPlainObject(perRepoConfig.hooks) ? perRepoConfig.hooks : {};
-    const localHooks = isPlainObject(localConfig.config.hooks) ? localConfig.config.hooks : {};
+    const perRepoHooks = isPlainObject(perRepoConfig.hooks)
+        ? perRepoConfig.hooks
+        : {};
+    const localHooks = isPlainObject(localConfig.config.hooks)
+        ? localConfig.config.hooks
+        : {};
     if (Object.keys(globalHooks).length > 0 ||
         Object.keys(perRepoHooks).length > 0 ||
         Object.keys(localHooks).length > 0) {
@@ -79,7 +83,7 @@ export async function loadGlobalConfig(home = homedir()) {
 }
 export async function saveLocalConfig(root, config) {
     const path = join(root, CONFIG_FILE_NAME);
-    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
     return path;
 }
 export async function updateLocalConfigKey(root, key, value) {
@@ -94,7 +98,7 @@ export async function updateLocalConfigKey(root, key, value) {
 export async function saveGlobalConfig(config, home = homedir()) {
     const path = GLOBAL_CONFIG_FILE_PATH(home);
     await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
     return path;
 }
 export async function unsetGlobalConfigKey(key, home = homedir()) {
@@ -115,8 +119,12 @@ export async function updateGlobalConfigKey(key, value, home = homedir()) {
 }
 export async function updateGlobalRepoConfigKey(repoRoot, key, value, home = homedir()) {
     const loaded = await loadGlobalConfig(home);
-    const repos = isPlainObject(loaded.config.repos) ? { ...loaded.config.repos } : {};
-    const existing = isPlainObject(repos[repoRoot]) ? repos[repoRoot] : {};
+    const repos = isPlainObject(loaded.config.repos)
+        ? { ...loaded.config.repos }
+        : {};
+    const existing = isPlainObject(repos[repoRoot])
+        ? repos[repoRoot]
+        : {};
     repos[repoRoot] = { ...existing, [key]: value };
     const nextConfig = { ...loaded.config, repos };
     await saveGlobalConfig(nextConfig, home);
@@ -139,11 +147,11 @@ export function parseConfigValue(value) {
 }
 export function resolveConfigString(config, key) {
     const value = config[key];
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 async function loadConfigFile(path) {
     try {
-        const rawConfig = await readFile(path, 'utf8');
+        const rawConfig = await readFile(path, "utf8");
         const parsedConfig = JSON.parse(rawConfig);
         return {
             config: mergeConfig(parsedConfig),
@@ -178,25 +186,23 @@ function findPerRepoConfig(repos, repoRoot, home) {
     return {};
 }
 function expandTilde(value, home) {
-    if (value === '~')
+    if (value === "~")
         return home;
-    if (value.startsWith('~/'))
+    if (value.startsWith("~/"))
         return join(home, value.slice(2));
     return value;
 }
 function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isMissingFileError(error) {
-    return (error instanceof Error &&
-        'code' in error &&
-        error.code === 'ENOENT');
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function warnUnknownKeys(config, filePath, knownKeys, onWarning) {
     for (const key of Object.keys(config)) {
         if (!knownKeys.has(key)) {
             const suggestion = closestKey(key, knownKeys);
-            const hint = suggestion ? ` (did you mean "${suggestion}"?)` : '';
+            const hint = suggestion ? ` (did you mean "${suggestion}"?)` : "";
             onWarning(`gji: unknown config key "${key}" in ${filePath}${hint}\n`);
         }
     }

package/dist/conflict.d.ts

@@ -1,3 +1,3 @@
-export type PathConflictChoice = 'abort' | 'reuse';
+export type PathConflictChoice = "abort" | "reuse";
 export declare function pathExists(path: string): Promise<boolean>;
 export declare function promptForPathConflict(path: string): Promise<PathConflictChoice>;

package/dist/conflict.js

@@ -1,6 +1,6 @@
-import { access } from 'node:fs/promises';
-import { constants } from 'node:fs';
-import { isCancel, select } from '@clack/prompts';
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { isCancel, select } from "@clack/prompts";
 export async function pathExists(path) {
     try {
         await access(path, constants.F_OK);
@@ -14,12 +14,20 @@ export async function promptForPathConflict(path) {
     const choice = await select({
         message: `Target path already exists: ${path}`,
         options: [
-            { value: 'abort', label: 'Abort', hint: 'Keep the existing directory untouched' },
-            { value: 'reuse', label: 'Reuse path', hint: 'Print the existing path and stop' },
+            {
+                value: "abort",
+                label: "Abort",
+                hint: "Keep the existing directory untouched",
+            },
+            {
+                value: "reuse",
+                label: "Reuse path",
+                hint: "Print the existing path and stop",
+            },
         ],
     });
     if (isCancel(choice)) {
-        return 'abort';
+        return "abort";
     }
     return choice;
 }

package/dist/editor.js

@@ -1,17 +1,37 @@
-import { spawn } from 'node:child_process';
+import { spawn } from "node:child_process";
 // Ordered by likely popularity among the target audience.
 export const EDITORS = [
-    { cli: 'cursor', name: 'Cursor', newWindowFlag: '--new-window', supportsWorkspace: true },
-    { cli: 'code', name: 'VS Code', newWindowFlag: '--new-window', supportsWorkspace: true },
-    { cli: 'windsurf', name: 'Windsurf', newWindowFlag: '--new-window', supportsWorkspace: true },
-    { cli: 'zed', name: 'Zed', supportsWorkspace: false },
-    { cli: 'subl', name: 'Sublime Text', newWindowFlag: '--new-window', supportsWorkspace: false },
+    {
+        cli: "cursor",
+        name: "Cursor",
+        newWindowFlag: "--new-window",
+        supportsWorkspace: true,
+    },
+    {
+        cli: "code",
+        name: "VS Code",
+        newWindowFlag: "--new-window",
+        supportsWorkspace: true,
+    },
+    {
+        cli: "windsurf",
+        name: "Windsurf",
+        newWindowFlag: "--new-window",
+        supportsWorkspace: true,
+    },
+    { cli: "zed", name: "Zed", supportsWorkspace: false },
+    {
+        cli: "subl",
+        name: "Sublime Text",
+        newWindowFlag: "--new-window",
+        supportsWorkspace: false,
+    },
 ];
 export async function defaultSpawnEditor(cli, args) {
-    const child = spawn(cli, args, { detached: true, stdio: 'ignore' });
+    const child = spawn(cli, args, { detached: true, stdio: "ignore" });
     await new Promise((resolve, reject) => {
-        child.once('error', reject);
-        child.once('spawn', resolve);
+        child.once("error", reject);
+        child.once("spawn", resolve);
     });
     child.unref();
 }

package/dist/file-sync.d.ts

@@ -7,3 +7,4 @@
  * - Rejects patterns that are absolute paths or contain `..` segments.
  */
 export declare function syncFiles(mainRoot: string, targetPath: string, patterns: string[]): Promise<void>;
+export declare function validateSyncFilePattern(pattern: string): string;

package/dist/file-sync.js

@@ -1,5 +1,5 @@
-import { copyFile, mkdir, stat } from 'node:fs/promises';
-import { dirname, isAbsolute, join, normalize } from 'node:path';
+import { copyFile, mkdir, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, normalize } from "node:path";
 /**
  * Copies files matching each pattern (relative to mainRoot) into the equivalent
  * relative path under targetPath, creating parent directories as needed.
@@ -10,13 +10,7 @@ import { dirname, isAbsolute, join, normalize } from 'node:path';
  */
 export async function syncFiles(mainRoot, targetPath, patterns) {
     for (const pattern of patterns) {
-        if (isAbsolute(pattern)) {
-            throw new Error(`syncFiles: pattern must be a relative path, got: ${pattern}`);
-        }
-        const normalized = normalize(pattern);
-        if (normalized.startsWith('..')) {
-            throw new Error(`syncFiles: pattern must not contain '..' segments, got: ${pattern}`);
-        }
+        const normalized = validateSyncFilePattern(pattern);
         const sourcePath = join(mainRoot, normalized);
         const destPath = join(targetPath, normalized);
         // Skip silently if source does not exist
@@ -33,6 +27,16 @@ export async function syncFiles(mainRoot, targetPath, patterns) {
         await copyFile(sourcePath, destPath);
     }
 }
+export function validateSyncFilePattern(pattern) {
+    if (isAbsolute(pattern)) {
+        throw new Error(`syncFiles: pattern must be a relative path, got: ${pattern}`);
+    }
+    const normalized = normalize(pattern);
+    if (normalized.startsWith("..")) {
+        throw new Error(`syncFiles: pattern must not contain '..' segments, got: ${pattern}`);
+    }
+    return normalized;
+}
 async function fileExists(path) {
     try {
         await stat(path);
@@ -47,6 +51,6 @@ async function fileExists(path) {
 }
 function isNotFoundError(error) {
     return (error instanceof Error &&
-        'code' in error &&
-        error.code === 'ENOENT');
+        "code" in error &&
+        error.code === "ENOENT");
 }

package/dist/git.d.ts

@@ -3,7 +3,7 @@ export interface WorktreeHealth {
     behind: number;
     hasUpstream: boolean;
     upstreamGone: boolean;
-    status: 'clean' | 'dirty';
+    status: "clean" | "dirty";
 }
 export declare function runGit(cwd: string, args: string[]): Promise<string>;
 export declare function readWorktreeHealth(cwd: string): Promise<WorktreeHealth>;

package/dist/git.js

@@ -1,9 +1,9 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 export async function runGit(cwd, args) {
     try {
-        const { stdout } = await execFileAsync('git', args, { cwd });
+        const { stdout } = await execFileAsync("git", args, { cwd });
         return stdout.trim();
     }
     catch (error) {
@@ -12,16 +12,18 @@ export async function runGit(cwd, args) {
     }
 }
 export async function readWorktreeHealth(cwd) {
-    const { stdout } = await execFileAsync('git', ['status', '--porcelain=v2', '--branch'], { 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';
+    return health.status === "dirty";
 }
-export async function isBranchMergedInto(cwd, branch, base = 'HEAD') {
+export async function isBranchMergedInto(cwd, branch, base = "HEAD") {
     try {
-        await execFileAsync('git', ['merge-base', '--is-ancestor', branch, base], { cwd });
+        await execFileAsync("git", ["merge-base", "--is-ancestor", branch, base], {
+            cwd,
+        });
         return true;
     }
     catch (error) {
@@ -32,10 +34,10 @@ export async function isBranchMergedInto(cwd, branch, base = 'HEAD') {
     }
 }
 export async function resolveRemoteDefaultBranch(cwd, remote) {
-    const { stdout } = await execFileAsync('git', ['ls-remote', '--symref', remote, 'HEAD'], { cwd });
+    const { stdout } = await execFileAsync("git", ["ls-remote", "--symref", remote, "HEAD"], { cwd });
     const refLine = stdout
-        .split('\n')
-        .find((line) => line.startsWith('ref: refs/heads/'));
+        .split("\n")
+        .find((line) => line.startsWith("ref: refs/heads/"));
     if (!refLine) {
         return null;
     }
@@ -44,7 +46,7 @@ export async function resolveRemoteDefaultBranch(cwd, remote) {
 }
 export async function readBranchLastCommitTimestamp(cwd, branch) {
     try {
-        const { stdout } = await execFileAsync('git', ['log', '-1', '--format=%ct', branch], { cwd });
+        const { stdout } = await execFileAsync("git", ["log", "-1", "--format=%ct", branch], { cwd });
         const timestamp = Number(stdout.trim());
         return Number.isFinite(timestamp) ? timestamp : null;
     }
@@ -58,12 +60,12 @@ function parseWorktreeHealth(output) {
     let hasUpstream = false;
     let hasAb = false;
     let dirty = false;
-    for (const line of output.split('\n').filter(Boolean)) {
-        if (line.startsWith('# branch.upstream ')) {
+    for (const line of output.split("\n").filter(Boolean)) {
+        if (line.startsWith("# branch.upstream ")) {
             hasUpstream = true;
             continue;
         }
-        if (line.startsWith('# branch.ab ')) {
+        if (line.startsWith("# branch.ab ")) {
             const match = /^# branch\.ab \+(\d+) -(\d+)$/.exec(line);
             if (!match) {
                 throw new Error(`Unexpected branch.ab output: '${line}'`);
@@ -73,7 +75,7 @@ function parseWorktreeHealth(output) {
             behind = Number(match[2]);
             continue;
         }
-        if (!line.startsWith('# ')) {
+        if (!line.startsWith("# ")) {
             dirty = true;
         }
     }
@@ -82,11 +84,11 @@ function parseWorktreeHealth(output) {
         behind,
         hasUpstream,
         upstreamGone: hasUpstream && !hasAb,
-        status: dirty ? 'dirty' : 'clean',
+        status: dirty ? "dirty" : "clean",
     };
 }
 function hasExitCode(error, code) {
-    return error instanceof Error
-        && 'code' in error
-        && error.code === code;
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
 }