@ivotoby/postgram-cli 1.39.0 → 1.40.1

package/dist/tracking/where.js

@@ -105,9 +105,33 @@ export function augmentWhere(response, input) {
     });
     return { ...response, groups };
 }
-const CUT_WIDTH = 60;
-function cut(line) {
-    return line.length > CUT_WIDTH ? `${line.slice(0, CUT_WIDTH - 1)}…` : line;
+const PATH_WIDTH = 70;
+/**
+ * Home-relative for local workspaces. A path that is still too long loses its
+ * leading segments, never its end: the end is what tells worktrees apart.
+ */
+function displayPath(workspace, input) {
+    let shown = workspace.path;
+    const home = input.homeDir;
+    if (home !== undefined &&
+        workspace.machine === input.localAlias &&
+        (shown === home || shown.startsWith(`${home}/`))) {
+        shown = `~${shown.slice(home.length)}`;
+    }
+    if (shown.length <= PATH_WIDTH) {
+        return shown;
+    }
+    const segments = shown.split('/');
+    let tail = segments.pop() ?? '';
+    while (segments.length > 1) {
+        const next = segments[segments.length - 1] ?? '';
+        if (`…/${next}/${tail}`.length > PATH_WIDTH) {
+            break;
+        }
+        tail = `${next}/${tail}`;
+        segments.pop();
+    }
+    return `…/${tail}`;
 }
 function workspaceLines(workspace, input) {
     const risks = displayRisks(workspace, input).map((risk) => riskText(risk, workspace));
@@ -138,13 +162,49 @@ function workspaceLines(workspace, input) {
         })
             .join(', ');
     }
-    const line2 = `  ${workspace.path}  git ${gitAge}  ${sessions}`;
+    const line2 = `  ${displayPath(workspace, input)}  git ${gitAge}  ${sessions}`;
     const resume = renderResume(workspace, {
         localAlias: input.localAlias,
         templates: input.templates,
         transcriptGone: transcriptGone(workspace, input)
     });
-    return [cut(line1), cut(line2), `  resume: ${resume}`];
+    return [line1, line2, `  resume: ${resume}`];
+}
+function riskLabels(workspace, input) {
+    return displayRisks(workspace, input).map((risk) => riskText(risk, workspace));
+}
+function latestWorkspace(workspaces) {
+    let latest = null;
+    for (const workspace of workspaces) {
+        if (latest === null ||
+            Date.parse(workspace.last_activity_at) > Date.parse(latest.last_activity_at)) {
+            latest = workspace;
+        }
+    }
+    return latest;
+}
+function compactFeatureLines(workspaces, input) {
+    const withRisks = workspaces.filter((workspace) => displayRisks(workspace, input).length > 0).length;
+    const latest = latestWorkspace(workspaces);
+    const lines = [
+        `  ${workspaces.length} workspaces, ${withRisks} with risks (--expand lists them)`
+    ];
+    if (latest !== null) {
+        lines.push(`  latest: ${latest.machine}  ${latest.branch ?? '-'}  ${displayPath(latest, input)}  ${formatAge(latest.last_activity_at, input.now)}`, `  resume: ${renderResume(latest, {
+            localAlias: input.localAlias,
+            templates: input.templates,
+            transcriptGone: transcriptGone(latest, input)
+        })}`);
+    }
+    return lines;
+}
+function compactWorkspaceLine(workspace, input) {
+    const parts = [displayPath(workspace, input), workspace.machine, workspace.branch ?? '-'];
+    const risks = riskLabels(workspace, input);
+    if (risks.length > 0) {
+        parts.push(risks.join(' '));
+    }
+    return `  ${parts.join('  ')}`;
 }
 export function renderWhere(response, input) {
     const lines = [];
@@ -159,8 +219,13 @@ export function renderWhere(response, input) {
                     .map((pullRequest) => ` PR:${pullRequest.state}`)
                     .join('');
                 lines.push(`${shortId(feature.id)} ${feature.title}  [${feature.stage}]${pullRequests}`);
-                for (const workspace of feature.workspaces) {
-                    lines.push(...workspaceLines(workspace, input));
+                if (input.expand === true || feature.workspaces.length <= 1) {
+                    for (const workspace of feature.workspaces) {
+                        lines.push(...workspaceLines(workspace, input));
+                    }
+                }
+                else {
+                    lines.push(...compactFeatureLines(feature.workspaces, input));
                 }
             }
         }
@@ -170,7 +235,12 @@ export function renderWhere(response, input) {
             }
             lines.push(`== ${group.label} (${group.workspaces.length}) ==`);
             for (const workspace of group.workspaces) {
-                lines.push(...workspaceLines(workspace, input));
+                if (input.expand === true || group.workspaces.length <= 1) {
+                    lines.push(...workspaceLines(workspace, input));
+                }
+                else {
+                    lines.push(compactWorkspaceLine(workspace, input));
+                }
             }
         }
     }
@@ -199,7 +269,9 @@ export async function runWhere(options, deps) {
         templates: deps.templates,
         now: deps.now,
         exists: deps.exists,
-        failedIds
+        failedIds,
+        ...(deps.homeDir !== undefined ? { homeDir: deps.homeDir } : {}),
+        ...(options.expand === true ? { expand: true } : {})
     };
     return deps.json ? augmentWhere(response, input) : renderWhere(response, input);
 }
@@ -211,21 +283,24 @@ export function registerWhereCommand(program) {
         .option('--machine <alias>', 'only workspaces on this machine')
         .option('--repo <remote>', 'only workspaces of this repo')
         .option('--all', 'include released and done features')
-        .option('--include-ended', 'include ended sessions')).action(async () => {
+        .option('--include-ended', 'include ended sessions')
+        .option('--expand', 'list every workspace instead of a summary per feature')).action(async () => {
         const opts = command.opts();
         await runTrackingCommand(command, (context) => runWhere({
             actions: opts.actions === true,
             ...(opts.machine !== undefined ? { machine: opts.machine } : {}),
             ...(opts.repo !== undefined ? { repo: opts.repo } : {}),
             all: opts.all === true,
-            includeEnded: opts.includeEnded === true
+            includeEnded: opts.includeEnded === true,
+            expand: opts.expand === true
         }, {
             client: context.client,
             json: context.json,
             localAlias: context.config.alias,
             templates: context.config.resume,
             now: new Date(),
-            exists: existsSync
+            exists: existsSync,
+            homeDir: context.homeDir
         }));
     });
 }

package/dist/tracking/workspace-commands.js

@@ -0,0 +1,94 @@
+// cli/src/tracking/workspace-commands.ts: pgm workspace prune.
+import { existsSync } from 'node:fs';
+import { shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { isIgnoredPath, usageExit } from './config.js';
+/**
+ * Removes workspace registrations of this machine whose directory is gone
+ * (and, with `ignored`, those under ignore_paths). Features are never touched.
+ */
+export async function runWorkspacePrune(options, deps) {
+    const { workspaces } = await deps.client.listWorkspaces({
+        machine: deps.config.alias
+    });
+    const result = {
+        removed: [],
+        failed: [],
+        dry_run: options.dryRun
+    };
+    for (const workspace of workspaces) {
+        if (workspace.machine !== deps.config.alias) {
+            continue;
+        }
+        let reason = null;
+        if (!deps.exists(workspace.path)) {
+            reason = 'missing';
+        }
+        else if (options.ignored === true &&
+            isIgnoredPath(workspace.path, deps.config.ignorePaths)) {
+            reason = 'ignored';
+        }
+        if (reason === null) {
+            continue;
+        }
+        if (!options.dryRun) {
+            try {
+                await deps.client.deleteWorkspace(workspace.id);
+            }
+            catch (error) {
+                result.failed.push({
+                    id: workspace.id,
+                    path: workspace.path,
+                    error: error instanceof Error ? error.message : 'delete failed'
+                });
+                continue;
+            }
+        }
+        result.removed.push({
+            id: workspace.id,
+            path: workspace.path,
+            feature_id: workspace.feature_id,
+            reason
+        });
+    }
+    return result;
+}
+export function formatPrune(result) {
+    const verb = result.dry_run ? 'would remove' : 'removed';
+    const lines = result.removed.map((entry) => {
+        const feature = entry.feature_id !== null ? ` (feature ${shortId(entry.feature_id)})` : '';
+        return `${verb} ${entry.path} [${entry.reason}]${feature}`;
+    });
+    for (const entry of result.failed) {
+        lines.push(`failed ${entry.path}: ${entry.error}`);
+    }
+    if (lines.length === 0) {
+        lines.push('nothing to prune');
+    }
+    return lines;
+}
+export function registerWorkspaceCommands(program) {
+    const workspace = usageExit(program.command('workspace').description('Manage workspace registrations'));
+    const prune = usageExit(workspace
+        .command('prune')
+        .description('Remove registrations of this machine whose directory is gone (features are kept)')
+        .option('--dry-run', 'show what would be removed without deleting')
+        .option('--ignored', 'also remove registrations that match ignore_paths in ~/.pgmrc'));
+    prune.action(async () => {
+        const opts = prune.opts();
+        await runTrackingCommand(prune, async (context) => {
+            const result = await runWorkspacePrune({
+                dryRun: opts.dryRun === true,
+                ...(opts.ignored === true ? { ignored: true } : {})
+            }, {
+                client: context.client,
+                config: context.config,
+                exists: existsSync
+            });
+            if (result.failed.length > 0) {
+                process.exitCode = 1;
+            }
+            return context.json ? result : formatPrune(result);
+        });
+    });
+}

package/dist/tracking/worktree.js

@@ -1,5 +1,6 @@
 // cli/src/tracking/worktree.ts: pgm worktree new — create a feature worktree.
 import { existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { AppError, ErrorCode } from '../errors.js';
@@ -145,6 +146,69 @@ export async function runWorktreeNew(feature, options, deps) {
     }
     return [worktreePath];
 }
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
+/**
+ * Removes a linked worktree only when nothing would be lost: no changed files
+ * and no commits that no remote has. There is no force flag and `git worktree
+ * remove` runs without --force. The workspace registration goes afterwards.
+ */
+export async function runWorktreeRemove(target, deps) {
+    const abs = path.resolve(deps.cwd, target);
+    if (!deps.exists(abs)) {
+        throw new UsageError(`no such directory: ${abs}`);
+    }
+    const local = await deps.resolveWorkspace(abs);
+    if (local.kind === 'timeout') {
+        throw new AppError(ErrorCode.INTERNAL, 'git timed out reading the worktree state; nothing was removed');
+    }
+    if (local.repoRoot === null) {
+        throw new UsageError(`not a git worktree: ${abs}`);
+    }
+    if (local.path !== (await deps.realpath(abs))) {
+        throw new UsageError(`not the root of a worktree: pass ${local.path} instead of ${abs}`);
+    }
+    if (local.repoRoot === local.path) {
+        throw new UsageError(`refusing to remove the main working tree: ${local.path}`);
+    }
+    const git = local.workspace.git ?? null;
+    const reasons = [];
+    if (git === null) {
+        reasons.push('git state is unknown');
+    }
+    else {
+        if (git.dirty_count > 0) {
+            reasons.push(plural(git.dirty_count, 'changed file'));
+        }
+        if (git.unpushed_count > 0) {
+            reasons.push(`${plural(git.unpushed_count, 'unpushed commit')}${git.has_upstream ? '' : ' (no upstream; no remote has them)'}`);
+        }
+    }
+    if (reasons.length > 0) {
+        throw new AppError(ErrorCode.CONFLICT, `refusing to remove ${local.path}: ${reasons.join(', ')}`);
+    }
+    const commonDir = await deps.run(['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: local.path, timeoutMs: GIT_TIMEOUT_MS });
+    if (commonDir.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, 'could not determine the git common dir');
+    }
+    const removed = await deps.run(['--git-dir', commonDir.stdout, 'worktree', 'remove', local.path], { cwd: local.repoRoot, timeoutMs: GIT_TIMEOUT_MS });
+    if (removed.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, `git worktree remove failed${removed.timedOut ? ' (timed out)' : ''}; nothing was unregistered`);
+    }
+    let unregistered = false;
+    try {
+        const looked = await deps.client.lookup(deps.config.alias, local.path);
+        if (looked.workspace !== null && looked.workspace.path === local.path) {
+            await deps.client.deleteWorkspace(looked.workspace.id);
+            unregistered = true;
+        }
+    }
+    catch (error) {
+        deps.warn(`worktree removed, but unregistering failed: ${error instanceof Error ? error.message : 'unknown error'}; run \`pgm workspace prune\` later`);
+    }
+    return { path: local.path, removed: true, unregistered };
+}
 async function promptConfirm(question) {
     process.stderr.write(`${question} [y/N] `);
     const answer = (await readStdinText()).trim().toLowerCase();
@@ -160,6 +224,28 @@ export function registerWorktreeCommand(program) {
         .option('--base <ref>', 'base ref for the new branch (default: origin/HEAD or HEAD)')
         .option('--path <dir>', 'worktree path (default: <worktree_root>/<8-hex>-<slug>)')
         .option('--create', 'create the feature when it does not exist'));
+    const removeCommand = usageExit(worktree
+        .command('rm <path>')
+        .description('Remove a clean worktree and unregister it. Refuses when there are changed files or unpushed commits; there is no force flag'));
+    removeCommand.action(async (target) => {
+        await runTrackingCommand(removeCommand, async (context) => {
+            const result = await runWorktreeRemove(target, {
+                client: context.client,
+                config: context.config,
+                cwd: process.cwd(),
+                run: runGit,
+                exists: existsSync,
+                realpath: (p) => realpath(p),
+                resolveWorkspace: (cwd) => resolveLocalWorkspace(cwd, { budgetMs: 5000 }),
+                warn: (line) => process.stderr.write(`${line}\n`)
+            });
+            return context.json
+                ? result
+                : [
+                    `removed ${result.path}${result.unregistered ? ' and unregistered the workspace' : ''}`
+                ];
+        });
+    });
     newCommand.action(async (feature) => {
         const opts = newCommand.opts();
         await runTrackingCommand(newCommand, async (context) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ivotoby/postgram-cli",
-  "version": "1.39.0",
+  "version": "1.40.1",
   "description": "Postgram CLI — store, search, and manage entities from the command line",
   "type": "module",
   "bin": {