@solaqua/gji 0.11.0 → 0.12.0

package/dist/cli.d.ts

@@ -1,8 +1,12 @@
 import { Command } from "commander";
+import { type HubCommandDependencies } from "./hub.js";
 import { type PrOpenCommandDependencies } from "./pr-open.js";
 export interface RunCliOptions {
+    columns?: number;
     cwd?: string;
+    now?: number;
     prOpenDependencies?: Partial<PrOpenCommandDependencies>;
+    hubDependencies?: Partial<HubCommandDependencies>;
     stderr?: (chunk: string) => void;
     stdout?: (chunk: string) => void;
 }

package/dist/cli.js

@@ -10,6 +10,7 @@ import { runDoneCommand } from "./done.js";
 import { runGoCommand } from "./go.js";
 import { isHeadless } from "./headless.js";
 import { runHistoryCommand } from "./history-command.js";
+import { runHubCommand } from "./hub.js";
 import { runInitCommand } from "./init.js";
 import { runLsCommand } from "./ls.js";
 import { runNewCommand } from "./new.js";
@@ -24,6 +25,7 @@ import { runHookCommand } from "./run-hook.js";
 import { runStatusCommand } from "./status.js";
 import { runSyncCommand } from "./sync.js";
 import { runSyncFilesCommand } from "./sync-files-command.js";
+import { runTaskCommand } from "./task-command.js";
 import { runUndoCommand } from "./undo.js";
 import { runWarpCommand } from "./warp.js";
 export function createProgram() {
@@ -56,7 +58,7 @@ export async function runCli(argv, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const stdout = options.stdout ?? (() => undefined);
     const stderr = options.stderr ?? (() => undefined);
-    if (shouldRegisterCurrentRepo(argv)) {
+    if (shouldRegisterCurrentRepo(argv) || isHubInvocation(argv)) {
         await maybeRegisterCurrentRepo(cwd);
     }
     const program = createProgram();
@@ -65,9 +67,16 @@ export async function runCli(argv, options = {}) {
         writeOut: stdout,
     });
     program.exitOverride();
-    if (argv.length === 0) {
-        program.outputHelp();
-        return { exitCode: 0 };
+    if (isHubInvocation(argv)) {
+        const exitCode = await runHubCommand({
+            columns: options.columns,
+            cwd,
+            json: argv.includes("--json"),
+            now: options.now,
+            stderr,
+            stdout,
+        }, options.hubDependencies);
+        return { exitCode };
     }
     try {
         attachCommandActions(program, {
@@ -131,6 +140,9 @@ function shouldRegisterCurrentRepo(argv) {
             "init",
         ].includes(command ?? ""));
 }
+function isHubInvocation(argv) {
+    return argv.length === 0 || (argv.length === 1 && argv[0] === "--json");
+}
 async function maybeRegisterCurrentRepo(cwd) {
     try {
         const { repoRoot } = await detectRepository(cwd);
@@ -149,6 +161,7 @@ function registerCommands(program) {
         .option("--from-current", "base the new branch on the current worktree instead of the main worktree (cannot be combined with --detached)")
         .option("--no-fetch", "skip refreshing the remote default branch before creating the new branch")
         .option("--take", "move current uncommitted changes into the new worktree")
+        .option("--task <description>", "record the purpose of the new worktree")
         .option("--copy", "copy current uncommitted changes instead of moving them (requires --take)")
         .option("--open", "open the new worktree in an editor after creation")
         .option("--editor <cli>", "editor CLI to use with --open (code, cursor, zed, …)")
@@ -221,6 +234,7 @@ function registerCommands(program) {
         .description("resolve and jump to a worktree path")
         .option("--root", "navigate to the main repository root")
         .option("--print", "print the resolved worktree path explicitly")
+        .option("--quiet", "suppress the context card")
         .option("--json", "emit JSON for an existing worktree destination")
         .action(notImplemented("go"));
     program
@@ -233,6 +247,12 @@ function registerCommands(program) {
         .description("summarize repository and worktree health")
         .option("--json", "print repository and worktree health as JSON")
         .action(notImplemented("status"));
+    program
+        .command("task [task]")
+        .description("show or update the current worktree task")
+        .option("--clear", "clear the current worktree task")
+        .option("--json", "emit task metadata as JSON")
+        .action(notImplemented("task"));
     program
         .command("sync")
         .description("fetch and update one or all worktrees")
@@ -329,6 +349,7 @@ function attachCommandActions(program, options) {
             json: commandOptions.json,
             open: commandOptions.open,
             take: commandOptions.take,
+            task: commandOptions.task,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
@@ -492,6 +513,7 @@ function attachCommandActions(program, options) {
             cwd: options.cwd,
             json: commandOptions.json,
             print: commandOptions.print,
+            quiet: commandOptions.quiet,
             root: commandOptions.root,
             stderr: options.stderr,
             stdout: options.stdout,
@@ -524,6 +546,20 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
+    program.commands
+        .find((command) => command.name() === "task")
+        ?.action(async (task, commandOptions) => {
+        const exitCode = await runTaskCommand({
+            clear: commandOptions.clear,
+            cwd: options.cwd,
+            json: commandOptions.json,
+            stderr: options.stderr,
+            task,
+            stdout: options.stdout,
+        });
+        if (exitCode !== 0)
+            throw commanderExit(exitCode);
+    });
     program.commands
         .find((command) => command.name() === "sync")
         ?.action(async (commandOptions) => {

package/dist/context-card.d.ts

@@ -0,0 +1 @@
+export declare function renderContextCard(worktreePath: string): Promise<string | null>;

package/dist/context-card.js

@@ -0,0 +1,25 @@
+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;
+    const rows = [`┌ ${info.branch ?? "(detached)"}`];
+    rows.push(`│ task   ${task.task}`);
+    rows.push(`│ state  ${formatState(info)}`);
+    if (info.lastCommitTimestamp !== null)
+        rows.push(`│ last   ${formatLastCommit(info)}`);
+    rows.push("└");
+    return rows.join("\n");
+}
+function formatState(info) {
+    return `${info.status}${info.upstream.kind === "tracked" ? ` · ↑${info.upstream.ahead} ↓${info.upstream.behind}` : ""}`;
+}
+function formatLastCommit(info) {
+    return new Date(info.lastCommitTimestamp).toISOString();
+}

package/dist/doctor.js

@@ -12,6 +12,7 @@ import { detectRepository } from "./repo.js";
 import { loadRegistry, REGISTRY_FILE_PATH, removeMissingRegistryEntries, } from "./repo-registry.js";
 import { resolveSupportedShell } from "./shell.js";
 import { executableExists, hasShellIntegration, resolveCompletionPath, resolveShellConfigPath, } from "./shell-setup.js";
+import { loadSlots } from "./slots.js";
 const execFileAsync = promisify(execFile);
 const MINIMUM_GIT_VERSION = { major: 2, minor: 17 };
 export async function runDoctorCommand(options) {
@@ -82,10 +83,30 @@ async function collectDoctorInspection(cwd, home, shell) {
             await checkWorktreeBase(repository, effectiveConfig, home),
             registry.check,
             await checkEditor(effectiveConfig),
+            await checkOrphanSlots(home),
         ],
         missingRegistryPaths: registry.missingPaths,
     };
 }
+async function checkOrphanSlots(home) {
+    const slots = await loadSlots(home);
+    const missing = (await Promise.all(Object.keys(slots).map(async (path) => {
+        try {
+            await access(path);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }))).filter(Boolean).length;
+    return {
+        id: "slots",
+        message: missing === 0
+            ? "worktree slots healthy"
+            : `${missing} orphaned worktree slot${missing === 1 ? "" : "s"}`,
+        status: "ok",
+    };
+}
 function buildDoctorFixes(missingRegistryPaths) {
     if (missingRegistryPaths.length === 0)
         return [];

package/dist/done.js

@@ -7,6 +7,7 @@ import { loadHistory } from "./history.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { detectRepository, listWorktrees } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { releaseWorktreeSlot } from "./slots.js";
 import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
 import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, removeWorktree, } from "./worktree-management.js";
 const DONE_OUTPUT_FILE_ENV = "GJI_DONE_OUTPUT_FILE";
@@ -122,6 +123,7 @@ export async function runDoneCommand(options) {
         }
     }
     await finalizeUndoOperation(journal, [target]);
+    await releaseWorktreeSlot(target.path);
     await runGit(repository.repoRoot, ["worktree", "prune"]).catch(() => undefined);
     const shouldMove = options.branch === undefined || target.path === repository.currentRoot;
     const movedTo = shouldMove