@solaqua/gji 0.11.0 → 0.12.0

package/dist/shell-completion.js

@@ -29,6 +29,7 @@ const TOP_LEVEL_COMMANDS = [
     { name: "jump", description: "alias of go" },
     { name: "root", description: "print the main repository root path" },
     { name: "status", description: "summarize repository and worktree health" },
+    { name: "task", description: "show or update the current worktree task" },
     { name: "sync", description: "fetch and update one or all worktrees" },
     {
         name: "sync-files",
@@ -140,7 +141,7 @@ _gji_completion() {
   cur="\${COMP_WORDS[COMP_CWORD]:-}"
 
   if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=( $(compgen -W "${topLevelCommands}" -- "$cur") )
+		COMPREPLY=( $(compgen -W "${topLevelCommands} --json --help" -- "$cur") )
     return 0
   fi
 
@@ -148,7 +149,7 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-      COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --force --open --editor --dry-run --json --help" -- "$cur") )
+				COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --task --force --open --editor --dry-run --json --help" -- "$cur") )
       ;;
     done)
       COMPREPLY=( $(compgen -W "--force --keep-branch --json --help" -- "$cur") )
@@ -389,6 +390,7 @@ complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a de
 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)'
+complete -c gji -n '__fish_seen_subcommand_from new' -l task -r -d 'record the purpose of the new worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l force -d 'remove and recreate the worktree if the target path already exists'
 complete -c gji -n '__fish_seen_subcommand_from new' -l open -d 'open the new worktree in an editor after creation'
 complete -c gji -n '__fish_seen_subcommand_from new' -l editor -r -d 'editor CLI to use with --open (code, cursor, zed, …)'
@@ -426,11 +428,14 @@ complete -c gji -n '__fish_seen_subcommand_from open' -a '(__gji_worktree_branch
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l print -d 'print the resolved worktree path explicitly'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l root -d 'navigate to the main repository root'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l json -d 'emit JSON for an existing worktree destination'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l quiet -d 'suppress the context card'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
 
 complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print repository and worktree health as JSON'
+complete -c gji -n '__fish_seen_subcommand_from task' -l clear -d 'clear the current worktree task'
+complete -c gji -n '__fish_seen_subcommand_from task' -l json -d 'emit task metadata as JSON'
 
 complete -c gji -n '__fish_seen_subcommand_from sync' -l all -d 'sync every worktree in the repository'
 complete -c gji -n '__fish_seen_subcommand_from sync' -l json -d 'emit JSON on success or error instead of human-readable output'
@@ -456,6 +461,8 @@ complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_b
 
 ${hookLines}
 
+complete -c gji -n '__fish_use_subcommand' -l json -d 'emit the repository hub as JSON'
+
 complete -c gji -n '__fish_seen_subcommand_from warp' -l print -d 'print the resolved worktree path without changing directory'
 complete -c gji -n '__fish_seen_subcommand_from warp' -l json -d 'emit JSON on success or error instead of human-readable output'
 
@@ -534,6 +541,7 @@ local -a command_entries worktree_branches
 
 command_entries=(
   ${commandLines}
+  '--json:emit the repository hub as JSON'
 )
 
 if (( CURRENT == 2 )); then
@@ -543,7 +551,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)]' '--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]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _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]' '--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/slots.d.ts

@@ -0,0 +1,8 @@
+export interface SlotStore {
+    [worktreePath: string]: number;
+}
+export declare function SLOTS_FILE_PATH(home?: string): string;
+export declare function loadSlots(home?: string): Promise<SlotStore>;
+export declare function assignWorktreeSlot(repoRoot: string, worktreePath: string, home?: string): Promise<number>;
+export declare function getWorktreeSlot(worktreePath: string, home?: string): Promise<number | null>;
+export declare function releaseWorktreeSlot(worktreePath: string, home?: string): Promise<void>;

package/dist/slots.js

@@ -0,0 +1,61 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+export function SLOTS_FILE_PATH(home = homedir()) {
+    const configDir = process.env.GJI_CONFIG_DIR;
+    return configDir
+        ? join(resolve(configDir), "slots.json")
+        : join(home, GLOBAL_CONFIG_DIRECTORY, "slots.json");
+}
+export async function loadSlots(home = homedir()) {
+    try {
+        const parsed = JSON.parse(await readFile(SLOTS_FILE_PATH(home), "utf8"));
+        if (!isSlotStore(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+export async function assignWorktreeSlot(repoRoot, worktreePath, home = homedir()) {
+    const slots = await loadSlots(home);
+    const existing = slots[worktreePath];
+    if (existing !== undefined)
+        return existing;
+    if (worktreePath !== repoRoot && slots[repoRoot] === undefined)
+        slots[repoRoot] = 0;
+    const used = new Set(Object.values(slots));
+    const slot = worktreePath === repoRoot ? 0 : nextAvailableSlot(used);
+    slots[worktreePath] = slot;
+    await saveSlots(slots, home);
+    return slot;
+}
+export async function getWorktreeSlot(worktreePath, home = homedir()) {
+    const slot = (await loadSlots(home))[worktreePath];
+    return slot === undefined ? null : slot;
+}
+export async function releaseWorktreeSlot(worktreePath, home = homedir()) {
+    const slots = await loadSlots(home);
+    if (!(worktreePath in slots))
+        return;
+    delete slots[worktreePath];
+    await saveSlots(slots, home);
+}
+async function saveSlots(slots, home) {
+    const path = SLOTS_FILE_PATH(home);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(slots, null, 2)}\n`, "utf8");
+}
+function nextAvailableSlot(used) {
+    let slot = 1;
+    while (used.has(slot))
+        slot += 1;
+    return slot;
+}
+function isSlotStore(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.values(value).every((slot) => Number.isInteger(slot) && slot >= 0));
+}

package/dist/status.d.ts

@@ -7,7 +7,9 @@ interface WorktreeStatusRow {
     branch: string | null;
     current: boolean;
     path: string;
+    slot: number | null;
     status: "clean" | "dirty";
+    task: string | null;
     upstream: UpstreamState;
 }
 type UpstreamState = {

package/dist/status.js

@@ -1,6 +1,8 @@
 import { readWorktreeHealth } from "./git.js";
 import { comparePaths } from "./paths.js";
 import { detectRepository, listWorktrees } from "./repo.js";
+import { getWorktreeSlot } from "./slots.js";
+import { readTask } from "./task.js";
 export async function runStatusCommand(options) {
     const repository = await detectRepository(options.cwd);
     const worktrees = sortWorktreesByPath(await listWorktrees(options.cwd));
@@ -36,12 +38,18 @@ export function formatStatusJson(repoRoot, currentRoot, rows) {
     };
 }
 async function buildStatusRow(worktree) {
-    const health = await readWorktreeHealth(worktree.path);
+    const [health, slot, task] = await Promise.all([
+        readWorktreeHealth(worktree.path),
+        getWorktreeSlot(worktree.path),
+        readTask(worktree.path),
+    ]);
     return {
         branch: worktree.branch,
         current: worktree.isCurrent,
         path: worktree.path,
+        slot,
         status: health.status,
+        task: task?.task ?? null,
         upstream: buildUpstreamState(worktree.branch, health),
     };
 }

package/dist/task-command.d.ts

@@ -0,0 +1,9 @@
+export interface TaskCommandOptions {
+    clear?: boolean;
+    cwd: string;
+    json?: boolean;
+    task?: string;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runTaskCommand(options: TaskCommandOptions): Promise<number>;

package/dist/task-command.js

@@ -0,0 +1,29 @@
+import { detectRepository } from "./repo.js";
+import { clearTask, readTask, writeTask } from "./task.js";
+export async function runTaskCommand(options) {
+    const repository = await detectRepository(options.cwd);
+    if (options.clear && options.task !== undefined)
+        return emitTaskError(options, "--clear cannot be combined with a task");
+    if (options.clear)
+        await clearTask(repository.currentRoot);
+    else if (options.task !== undefined)
+        await writeTask(repository.currentRoot, options.task);
+    const task = await readTask(repository.currentRoot);
+    if (options.json) {
+        options.stdout(`${JSON.stringify({ task: task?.task ?? null }, null, 2)}\n`);
+    }
+    else if (task) {
+        options.stdout(`${task.task}\n`);
+    }
+    else {
+        options.stdout('no task set — set one: gji task "..."\n');
+    }
+    return 0;
+}
+function emitTaskError(options, message) {
+    if (options.json)
+        options.stderr(`${JSON.stringify({ error: message })}\n`);
+    else
+        options.stderr(`gji task: ${message}\n`);
+    return 1;
+}

package/dist/task.d.ts

@@ -0,0 +1,9 @@
+export type TaskSource = "manual" | "pr";
+export interface TaskMetadata {
+    source: TaskSource;
+    task: string;
+    updatedAt: number;
+}
+export declare function readTask(worktreePath: string): Promise<TaskMetadata | null>;
+export declare function writeTask(worktreePath: string, task: string, source?: TaskSource): Promise<TaskMetadata>;
+export declare function clearTask(worktreePath: string): Promise<void>;

package/dist/task.js

@@ -0,0 +1,37 @@
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { worktreeGitDir } from "./repo.js";
+export async function readTask(worktreePath) {
+    try {
+        const parsed = JSON.parse(await readFile(await taskPath(worktreePath), "utf8"));
+        return isTaskMetadata(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeTask(worktreePath, task, source = "manual") {
+    const metadata = { source, task, updatedAt: Date.now() };
+    const path = await taskPath(worktreePath);
+    await writeFile(path, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+    return metadata;
+}
+export async function clearTask(worktreePath) {
+    try {
+        await unlink(await taskPath(worktreePath));
+    }
+    catch {
+        // Missing task metadata is already the desired state.
+    }
+}
+async function taskPath(worktreePath) {
+    return join(await worktreeGitDir(worktreePath), "gji-task.json");
+}
+function isTaskMetadata(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value;
+    return (typeof candidate.task === "string" &&
+        (candidate.source === "manual" || candidate.source === "pr") &&
+        typeof candidate.updatedAt === "number");
+}

package/dist/terminal-text.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeTerminalText(value: string): string;
+export declare function middleEllipsize(value: string, maxLength: number): string;
+export declare function startEllipsize(value: string, maxLength: number): string;
+export declare function terminalWidth(value: string): number;

package/dist/terminal-text.js

@@ -0,0 +1,72 @@
+export function sanitizeTerminalText(value) {
+    return Array.from(value, (character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)
+            ? " "
+            : character;
+    }).join("");
+}
+export function middleEllipsize(value, maxLength) {
+    if (terminalWidth(value) <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return "…";
+    const keep = maxLength - 1;
+    const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
+    const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
+    return `${start}…${end}`;
+}
+export function startEllipsize(value, maxLength) {
+    if (terminalWidth(value) <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return "…";
+    return `…${takeTerminalColumns(value, maxLength - 1, "end")}`;
+}
+export function terminalWidth(value) {
+    let width = 0;
+    for (const character of Array.from(value)) {
+        width += characterTerminalWidth(character);
+    }
+    return width;
+}
+function takeTerminalColumns(value, maxWidth, direction) {
+    const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
+    const kept = [];
+    let width = 0;
+    for (const character of characters) {
+        const characterWidth = characterTerminalWidth(character);
+        if (width + characterWidth > maxWidth)
+            break;
+        kept.push(character);
+        width += characterWidth;
+    }
+    return direction === "start" ? kept.join("") : kept.reverse().join("");
+}
+function characterTerminalWidth(character) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === undefined)
+        return 0;
+    if (isZeroWidthCodePoint(codePoint) || /\p{Mark}/u.test(character))
+        return 0;
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0 ||
+        codePoint === 0x200d ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}

package/dist/worktree-bootstrap.js

@@ -4,6 +4,7 @@ import { cloneDir } from "./dir-clone.js";
 import { syncFiles } from "./file-sync.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { assignWorktreeSlot } from "./slots.js";
 import { executeSyncDirectoryPlan, } from "./sync-directories.js";
 import { prepareSyncDirectoryPlan } from "./sync-plan.js";
 export async function bootstrapWorktree(options) {
@@ -73,10 +74,12 @@ export async function bootstrapWorktree(options) {
         await maybeRunInstallPrompt(options.worktreePath, options.repoRoot, options.config, options.reporter.write, options.installDependencies, options.nonInteractive);
     }
     const hooks = extractHooks(options.config);
+    const slot = await assignWorktreeSlot(options.repoRoot, options.worktreePath);
     await runHook(hooks["after-create"], options.worktreePath, {
         branch: options.branch,
         path: options.worktreePath,
         repo: basename(options.repoRoot),
+        slot,
     }, options.reporter.write, options.json
         ? () => undefined
         : (options.commandStdout ?? ((chunk) => process.stdout.write(chunk))));

package/dist/worktree-info.d.ts

@@ -2,14 +2,18 @@ import { type WorktreeHealth } from "./git.js";
 import type { WorktreeEntry } from "./repo.js";
 export interface WorktreeInfo extends WorktreeEntry {
     lastCommitTimestamp: number | null;
+    slot: number | null;
     status: WorktreeHealth["status"] | "unknown";
+    task: string | null;
     upstream: UpstreamState;
 }
 export interface SerializedWorktreeInfo {
     branch: string | null;
     lastCommitTimestamp: number | null;
     path: string;
+    slot: number | null;
     status: WorktreeInfo["status"];
+    task: string | null;
     upstream: UpstreamState;
 }
 export type UpstreamState = {
@@ -26,7 +30,8 @@ export type UpstreamState = {
     kind: "unknown";
 };
 export declare function readWorktreeInfos(worktrees: WorktreeEntry[]): Promise<WorktreeInfo[]>;
+export declare function readWorktreeInfo(worktree: WorktreeEntry): Promise<WorktreeInfo>;
 export declare function serializeWorktreeInfo(info: WorktreeInfo): SerializedWorktreeInfo;
 export declare function formatUpstreamState(upstream: UpstreamState): string;
 export declare function formatLastCommit(timestampSeconds: number | null): string;
-export declare function formatRelativeAge(timestampSeconds: number): string;
+export declare function formatRelativeAge(timestampSeconds: number, nowSeconds?: number): string;

package/dist/worktree-info.js

@@ -1,4 +1,6 @@
 import { readBranchLastCommitTimestamp, readWorktreeHealth, } from "./git.js";
+import { getWorktreeSlot } from "./slots.js";
+import { readTask } from "./task.js";
 const MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
 export async function readWorktreeInfos(worktrees) {
     return mapWithConcurrency(worktrees, MAX_WORKTREE_INFO_READ_CONCURRENCY, readWorktreeInfo);
@@ -18,19 +20,25 @@ async function mapWithConcurrency(items, limit, mapper) {
     await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
     return results;
 }
-async function readWorktreeInfo(worktree) {
-    const [healthResult, lastCommitResult] = await Promise.allSettled([
+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),
     };
 }
@@ -58,7 +66,9 @@ export function serializeWorktreeInfo(info) {
         branch: info.branch,
         lastCommitTimestamp: info.lastCommitTimestamp,
         path: info.path,
+        slot: info.slot,
         status: info.status,
+        task: info.task,
         upstream: info.upstream,
     };
 }
@@ -94,8 +104,8 @@ export function formatLastCommit(timestampSeconds) {
         ? "n/a"
         : formatRelativeAge(timestampSeconds);
 }
-export function formatRelativeAge(timestampSeconds) {
-    const ageSeconds = Math.max(0, Math.floor(Date.now() / 1000) - 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 },

package/dist/worktree-picker.d.ts

@@ -7,9 +7,9 @@ export interface WorktreePromptEntry extends WorktreeEntry {
     group: "recent" | "other";
     label: string;
     metadata?: string | null;
-    pullRequestNumbers?: number[];
-    pullRequestUrls?: string[];
+    pullRequests?: PullRequestInfo[];
     repoName: string;
+    task?: string | null;
 }
 export type QueryWorktreePullRequests = (repoRoot: string, sourceBranch: string) => Promise<PullRequestInfo[]>;
 export type QueryRepositoryPullRequests = (repoRoot: string) => Promise<PullRequestInfo[]>;
@@ -47,4 +47,4 @@ export declare function promptForSingleWorktree(message: string, worktrees: Work
     scope?: WorktreePromptScope;
 }): Promise<string | null>;
 export declare function promptForMultipleWorktrees(message: string, worktrees: WorktreePromptEntry[], io?: WorktreePickerIO): Promise<string[] | null>;
-export declare function formatWorktreeBranchLabel(branch: string | null, pullRequestNumbers?: number[]): string;
+export declare function formatWorktreeBranchLabel(branch: string | null, pullRequests?: PullRequestInfo[]): string;