@solaqua/gji 0.11.0 → 0.12.1

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/dependency-bootstrap.d.ts

@@ -1,9 +1,8 @@
-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 BootstrapState = "seeded" | "repaired" | "installed" | "repair-only" | "skipped" | "failed";
 export type BootstrapStrategy = "cow-then-repair" | "repair-only" | "install-only";
 export type BootstrapCommandRunner = CommandRunner;
 export interface BootstrapPreparationContext {
@@ -11,11 +10,14 @@ export interface BootstrapPreparationContext {
     sourceRoot: string;
     worktreePath: string;
 }
-export interface BootstrapExecutionContext {
+interface BootstrapCommandExecutionContext {
     runCommand: BootstrapCommandRunner;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
+export interface BootstrapExecutionContext extends BootstrapCommandExecutionContext {
+    input: BootstrapTargetInput;
+}
 export interface BootstrapTarget {
     adapter: string;
     kind: BootstrapKind;
@@ -26,19 +28,13 @@ export interface BootstrapTarget {
     targetPath: string;
     repairCommand: string;
     repairState: "repaired" | "installed";
-    existingBeforeBootstrap: boolean;
+    shell: boolean;
+    initialInput: Exclude<BootstrapTargetInput, "seed">;
 }
-export type BootstrapTargetOwnership = "adapter" | "syncDirs" | "empty" | "preserve";
+export type BootstrapTargetInput = "clean" | "preserve" | "seed";
 export interface BootstrapRepairFailureContext {
+    input: BootstrapTargetInput;
     target: BootstrapTarget;
-    ownership: BootstrapTargetOwnership;
-    targetExistedBeforeRepair: boolean;
-}
-export interface BootstrapOutputMetadata {
-    adapter: string;
-    kind: BootstrapKind;
-    target: string;
-    repairCommand: string;
 }
 export interface BootstrapAdapter {
     readonly kind: BootstrapKind;
@@ -49,7 +45,6 @@ export interface BootstrapAdapter {
     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>;
 }
@@ -58,7 +53,6 @@ export interface DependencyBootstrapPlan {
     targets: readonly PlannedBootstrapTarget[];
 }
 export interface PlannedBootstrapTarget {
-    adapter: BootstrapAdapter;
     target: BootstrapTarget;
     seedable: boolean;
 }
@@ -81,7 +75,6 @@ export interface DependencyBootstrapReport {
 }
 export interface DependencyBootstrapDependencies {
     cloneDirectory?: CloneDirectory;
-    failureStore?: CloneFailureStore;
     runCommand?: BootstrapCommandRunner;
     stderr?: (chunk: string) => void;
     stdout?: (chunk: string) => void;
@@ -124,6 +117,6 @@ export declare function detectDependencyBootstrapCandidate(context: {
 }): Promise<DependencyBootstrapCandidate | null>;
 export declare function previewDependencyBootstrap(plan: DependencyBootstrapPlan): DependencyBootstrapPreview;
 export declare function executeDependencyBootstrap(plan: DependencyBootstrapPlan, options: DependencyBootstrapDependencies & {
-    repoRoot: string;
     reporter: DependencyBootstrapReporter;
 }): Promise<DependencyBootstrapReport>;
+export {};