@ivotoby/postgram-cli 1.38.2 → 1.39.0

package/dist/tracking/scan.js

@@ -0,0 +1,261 @@
+// cli/src/tracking/scan.ts: pgm scan — discover worktrees and record their features.
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { slug, usageExit, UsageError } from './config.js';
+import { readMarker, resolveLocalWorkspace, writeMarker } from './local.js';
+import { discoverWorktrees, findClaudeSessions, findPiSessions } from './scan-discovery.js';
+import { syncMissing } from './where.js';
+export const BRANCH_SHORT_ID = /(?:^|\/)([0-9a-f]{8})(?:-|$)/;
+const DEFAULT_DEPTH = 3;
+function parseDepth(raw) {
+    if (raw === undefined) {
+        return DEFAULT_DEPTH;
+    }
+    if (!/^[1-9][0-9]*$/.test(raw)) {
+        throw new UsageError(`invalid --depth '${raw}': must be a positive integer`);
+    }
+    return Number.parseInt(raw, 10);
+}
+function withoutFeatPrefix(branch) {
+    return branch.startsWith('feat/') ? branch.slice('feat/'.length) : branch;
+}
+function newFeatureTitle(branch, dirName) {
+    if (branch === null || branch === '') {
+        return dirName;
+    }
+    return withoutFeatPrefix(branch).replaceAll('-', ' ');
+}
+async function buildProposals(worktree, deps, tasks, yesExact) {
+    const proposals = [];
+    const titleFor = (id) => tasks.find((task) => task.id === id)?.title ?? '';
+    const marker = await deps.readMarker(worktree.path);
+    if (marker !== null) {
+        proposals.push({ kind: 'marker', featureId: marker, title: titleFor(marker) });
+    }
+    if (worktree.branch !== null) {
+        const match = BRANCH_SHORT_ID.exec(worktree.branch);
+        const short = match?.[1];
+        if (short !== undefined) {
+            const hits = tasks.filter((task) => task.id.startsWith(short));
+            if (hits.length === 1) {
+                const hit = hits[0];
+                if (hit !== undefined) {
+                    proposals.push({ kind: 'short-id', featureId: hit.id, title: hit.title });
+                }
+            }
+        }
+        if (!yesExact) {
+            let hits = [];
+            try {
+                hits = await deps.search(slug(withoutFeatPrefix(worktree.branch)));
+            }
+            catch {
+                hits = [];
+            }
+            for (const hit of hits.slice(0, 3)) {
+                proposals.push({ kind: 'search', featureId: hit.id, title: hit.title });
+            }
+        }
+    }
+    return proposals;
+}
+function sessionsFor(worktree, claude, pi) {
+    return [
+        ...(claude.get(worktree.path) ?? []),
+        ...(pi.get(worktree.path) ?? [])
+    ];
+}
+export async function runScan(options, deps) {
+    const roots = options.root.length > 0
+        ? options.root.map((root) => path.resolve(root))
+        : deps.config.scanRoots;
+    if (roots.length === 0) {
+        throw new UsageError('no scan roots: pass --root <dir> or set scan_roots in ~/.pgmrc');
+    }
+    const depth = parseDepth(options.depth);
+    const knownResponse = await deps.client.listWorkspaces({
+        machine: deps.config.alias
+    });
+    if (!options.dryRun) {
+        await syncMissing(knownResponse.workspaces, {
+            localAlias: deps.config.alias,
+            exists: deps.exists,
+            patch: (id, missing) => deps.client.patchWorkspace(id, { missing })
+        });
+    }
+    const known = new Set(knownResponse.workspaces.map((workspace) => workspace.path));
+    const worktrees = await deps.discover(roots, depth);
+    const paths = worktrees.map((worktree) => worktree.path);
+    const claudeDir = deps.env.CLAUDE_CONFIG_DIR ?? path.join(deps.homeDir, '.claude');
+    const piDir = deps.env.PI_CODING_AGENT_DIR ?? path.join(deps.homeDir, '.pi', 'agent');
+    const claude = await deps.claudeSessions(paths, claudeDir);
+    for (const note of claude.notes) {
+        deps.info(note);
+    }
+    const pi = await deps.piSessions(paths, piDir);
+    const tasks = await deps.tasks();
+    const lines = [];
+    for (const worktree of worktrees) {
+        if (known.has(worktree.path)) {
+            lines.push(`known ${worktree.path}`);
+            continue;
+        }
+        const proposals = await buildProposals(worktree, deps, tasks, options.yesExact);
+        let featureId = null;
+        if (options.yesExact) {
+            const first = proposals[0];
+            if (first !== undefined &&
+                (first.kind === 'marker' || first.kind === 'short-id')) {
+                featureId = first.featureId;
+            }
+            else {
+                lines.push(`skipped ${worktree.path}`);
+                continue;
+            }
+        }
+        else {
+            deps.info(`${worktree.path}${worktree.branch !== null ? ` (${worktree.branch})` : ''}`);
+            proposals.forEach((proposal, index) => {
+                deps.info(`  ${index + 1}. ${proposal.kind}: ${proposal.title !== '' ? proposal.title : proposal.featureId}`);
+            });
+            const answer = (await deps.ask('[a]ccept, [1-3] pick, [n]ew feature, [s]kip'))
+                .trim()
+                .toLowerCase();
+            if (answer === 'a') {
+                const first = proposals[0];
+                if (first !== undefined) {
+                    featureId = first.featureId;
+                }
+            }
+            else if (/^[1-9]$/.test(answer)) {
+                const picked = proposals[Number.parseInt(answer, 10) - 1];
+                if (picked !== undefined) {
+                    featureId = picked.featureId;
+                }
+            }
+            else if (answer === 'n') {
+                const created = await deps.client.createFeature({
+                    content: newFeatureTitle(worktree.branch, path.basename(worktree.path))
+                });
+                featureId = created.entity.id;
+            }
+            if (featureId === null) {
+                lines.push(`skipped ${worktree.path}`);
+                continue;
+            }
+        }
+        const id = featureId;
+        if (options.dryRun) {
+            lines.push(`would record ${worktree.path} → ${shortId(id)}`);
+            continue;
+        }
+        const local = await deps.resolveWorkspace(worktree.path);
+        if (local.kind === 'timeout') {
+            lines.push(`skipped ${worktree.path} (git timeout)`);
+            continue;
+        }
+        const body = {
+            source: 'scan',
+            machine: {
+                alias: deps.config.alias,
+                hostname: deps.hostname,
+                boot_id: null
+            },
+            workspace: local.workspace,
+            feature_id: id,
+            sessions: sessionsFor(worktree, claude.sessions, pi)
+        };
+        await deps.client.report(body);
+        if ((await deps.readMarker(worktree.path)) !== id) {
+            await deps.writeMarker(worktree.path, id);
+        }
+        lines.push(`recorded ${worktree.path} → ${shortId(id)}`);
+    }
+    return lines;
+}
+function firstLineTitle(content) {
+    return (content ?? '').split('\n')[0]?.trim() ?? '';
+}
+function collectRoot(value, previous) {
+    return [...previous, value];
+}
+function askLine(question) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stderr
+        });
+        const finish = (answer) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            rl.close();
+            resolve(answer.trim());
+        };
+        rl.question(question, (answer) => finish(answer));
+        rl.on('close', () => finish(''));
+        rl.on('SIGINT', () => finish(''));
+    });
+}
+export function registerScanCommand(program) {
+    const command = usageExit(program
+        .command('scan')
+        .description('Discover worktrees under the scan roots and record their features')
+        .option('--root <dir>', 'scan root (repeatable)', collectRoot, [])
+        .option('--depth <n>', `directory depth below each root (default ${DEFAULT_DEPTH})`)
+        .option('--yes-exact', 'accept marker and short-id proposals, skip the rest')
+        .option('--dry-run', 'show what would be recorded without sending')).action(async () => {
+        const opts = command.opts();
+        await runTrackingCommand(command, (context) => runScan({
+            root: opts.root ?? [],
+            ...(opts.depth !== undefined ? { depth: opts.depth } : {}),
+            yesExact: opts.yesExact === true,
+            dryRun: opts.dryRun === true
+        }, {
+            client: context.client,
+            config: context.config,
+            hostname: os.hostname(),
+            env: process.env,
+            homeDir: context.homeDir,
+            tasks: async () => {
+                const items = [];
+                for (let offset = 0;; offset += 100) {
+                    const page = await context.pgm.listTasks({ limit: 100, offset });
+                    for (const item of page.items) {
+                        items.push({ id: item.id, title: firstLineTitle(item.content) });
+                    }
+                    if (page.items.length < 100) {
+                        break;
+                    }
+                }
+                return items;
+            },
+            search: async (query) => {
+                const response = await context.pgm.searchEntities({
+                    query,
+                    type: 'task',
+                    limit: 3
+                });
+                return response.results.map((result) => ({
+                    id: result.entity.id,
+                    title: firstLineTitle(result.entity.content)
+                }));
+            },
+            ask: askLine,
+            discover: discoverWorktrees,
+            claudeSessions: findClaudeSessions,
+            piSessions: findPiSessions,
+            resolveWorkspace: (p) => resolveLocalWorkspace(p),
+            readMarker,
+            writeMarker: (worktree, featureId) => writeMarker(worktree, featureId, new Date()),
+            exists: existsSync,
+            info: (line) => process.stderr.write(`${line}\n`)
+        }));
+    });
+}

package/dist/tracking/types.js

@@ -0,0 +1,14 @@
+export const AGENT_KINDS = [
+    'claude-code',
+    'pi',
+    'talon',
+    'other'
+];
+export const FEATURE_STAGES = [
+    'building',
+    'review',
+    'functional_test',
+    'ready_to_merge',
+    'awaiting_release',
+    'released'
+];

package/dist/tracking/where.js

@@ -0,0 +1,231 @@
+// cli/src/tracking/where.ts: pgm where — features and workspaces grouped by stage.
+import { existsSync } from 'node:fs';
+import { shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { usageExit } from './config.js';
+import { formatAge, isTranscriptGone, renderResume } from './resume.js';
+export function collectWorkspaces(response) {
+    const workspaces = [];
+    for (const group of response.groups) {
+        if ('features' in group) {
+            for (const feature of group.features) {
+                workspaces.push(...feature.workspaces);
+            }
+        }
+        else {
+            workspaces.push(...group.workspaces);
+        }
+    }
+    return workspaces;
+}
+export async function syncMissing(workspaces, deps) {
+    let changed = false;
+    const failedIds = new Set();
+    for (const workspace of workspaces) {
+        if (workspace.machine !== deps.localAlias) {
+            continue;
+        }
+        const present = deps.exists(workspace.path);
+        if (!present && workspace.missing_since === null) {
+            try {
+                await deps.patch(workspace.id, true);
+                changed = true;
+            }
+            catch {
+                failedIds.add(workspace.id);
+            }
+        }
+        else if (present && workspace.missing_since !== null) {
+            try {
+                await deps.patch(workspace.id, false);
+                changed = true;
+            }
+            catch {
+                // the workspace is present; nothing to mark locally
+            }
+        }
+    }
+    return { changed, failedIds };
+}
+function displayRisks(workspace, input) {
+    const risks = [...workspace.risks];
+    if (input.failedIds.has(workspace.id) &&
+        !input.exists(workspace.path) &&
+        !risks.includes('missing')) {
+        risks.push('missing');
+    }
+    return risks;
+}
+function riskText(risk, workspace) {
+    if (risk === 'dirty') {
+        const count = workspace.git?.dirty_count ?? null;
+        return count !== null ? `dirty:${count}` : risk;
+    }
+    if (risk === 'unpushed') {
+        const count = workspace.git?.unpushed_count ?? null;
+        return count !== null ? `unpushed:${count}` : risk;
+    }
+    return risk;
+}
+function transcriptGone(workspace, input) {
+    return isTranscriptGone(workspace, input.localAlias, input.exists);
+}
+function augmentedWorkspace(workspace, input) {
+    const gone = transcriptGone(workspace, input);
+    return {
+        ...workspace,
+        risks: displayRisks(workspace, input),
+        git: workspace.git !== null ? { ...workspace.git } : null,
+        resume_session: workspace.resume_session !== null ? { ...workspace.resume_session } : null,
+        sessions: workspace.sessions.map((session) => ({ ...session })),
+        resume: renderResume(workspace, {
+            localAlias: input.localAlias,
+            templates: input.templates,
+            transcriptGone: gone
+        }),
+        transcript_gone: gone
+    };
+}
+export function augmentWhere(response, input) {
+    const groups = response.groups.map((group) => {
+        if ('features' in group) {
+            const features = group.features.map((feature) => ({
+                ...feature,
+                pull_requests: feature.pull_requests.map((pullRequest) => ({
+                    ...pullRequest
+                })),
+                workspaces: feature.workspaces.map((workspace) => augmentedWorkspace(workspace, input))
+            }));
+            return { ...group, features };
+        }
+        return {
+            ...group,
+            workspaces: group.workspaces.map((workspace) => augmentedWorkspace(workspace, input))
+        };
+    });
+    return { ...response, groups };
+}
+const CUT_WIDTH = 60;
+function cut(line) {
+    return line.length > CUT_WIDTH ? `${line.slice(0, CUT_WIDTH - 1)}…` : line;
+}
+function workspaceLines(workspace, input) {
+    const risks = displayRisks(workspace, input).map((risk) => riskText(risk, workspace));
+    let line1 = `  ${workspace.machine}  ${workspace.branch ?? '-'}`;
+    if (risks.length > 0) {
+        line1 = `${line1}  ${risks.join(' ')}`;
+    }
+    const gitAge = workspace.git_state_at !== null
+        ? formatAge(workspace.git_state_at, input.now)
+        : '?';
+    let sessions;
+    if (workspace.sessions.length === 0) {
+        sessions = 'no sessions';
+    }
+    else {
+        const gone = transcriptGone(workspace, input);
+        const resumeId = workspace.resume_session?.id ?? null;
+        sessions = workspace.sessions
+            .map((session) => {
+            let text = `${session.agent_kind}/${session.status} ${formatAge(session.last_activity_at, input.now)}`;
+            if (session.dormant) {
+                text = `${text} dormant`;
+            }
+            if (gone && resumeId !== null && session.id === resumeId) {
+                text = `${text} transcript gone`;
+            }
+            return text;
+        })
+            .join(', ');
+    }
+    const line2 = `  ${workspace.path}  git ${gitAge}  ${sessions}`;
+    const resume = renderResume(workspace, {
+        localAlias: input.localAlias,
+        templates: input.templates,
+        transcriptGone: transcriptGone(workspace, input)
+    });
+    return [cut(line1), cut(line2), `  resume: ${resume}`];
+}
+export function renderWhere(response, input) {
+    const lines = [];
+    for (const group of response.groups) {
+        if ('features' in group) {
+            if (group.features.length === 0) {
+                continue;
+            }
+            lines.push(`== ${group.label} (${group.features.length}) ==`);
+            for (const feature of group.features) {
+                const pullRequests = feature.pull_requests
+                    .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));
+                }
+            }
+        }
+        else {
+            if (group.workspaces.length === 0) {
+                continue;
+            }
+            lines.push(`== ${group.label} (${group.workspaces.length}) ==`);
+            for (const workspace of group.workspaces) {
+                lines.push(...workspaceLines(workspace, input));
+            }
+        }
+    }
+    return lines;
+}
+export async function runWhere(options, deps) {
+    const query = {
+        view: options.actions ? 'actions' : 'stage',
+        ...(options.machine !== undefined ? { machine: options.machine } : {}),
+        ...(options.repo !== undefined ? { repo: options.repo } : {}),
+        includeReleased: options.all,
+        includeDone: options.all,
+        includeEnded: options.includeEnded
+    };
+    let response = await deps.client.where(query);
+    const { changed, failedIds } = await syncMissing(collectWorkspaces(response), {
+        localAlias: deps.localAlias,
+        exists: deps.exists,
+        patch: (id, missing) => deps.client.patchWorkspace(id, { missing })
+    });
+    if (changed) {
+        response = await deps.client.where(query);
+    }
+    const input = {
+        localAlias: deps.localAlias,
+        templates: deps.templates,
+        now: deps.now,
+        exists: deps.exists,
+        failedIds
+    };
+    return deps.json ? augmentWhere(response, input) : renderWhere(response, input);
+}
+export function registerWhereCommand(program) {
+    const command = usageExit(program
+        .command('where')
+        .description('Show features and workspaces grouped by stage')
+        .option('--actions', 'group by the next action instead of stage')
+        .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 () => {
+        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
+        }, {
+            client: context.client,
+            json: context.json,
+            localAlias: context.config.alias,
+            templates: context.config.resume,
+            now: new Date(),
+            exists: existsSync
+        }));
+    });
+}

package/dist/tracking/worktree.js

@@ -0,0 +1,187 @@
+// cli/src/tracking/worktree.ts: pgm worktree new — create a feature worktree.
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { AppError, ErrorCode } from '../errors.js';
+import { readStdinText, shortId } from '../shared.js';
+import { runTrackingCommand } from './api.js';
+import { UsageError, slug, usageExit } from './config.js';
+import { readBootId, resolveLocalWorkspace, runGit, writeMarker } from './local.js';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SHORT_ID_RE = /^[0-9a-f]{8}$/;
+const GIT_TIMEOUT_MS = 10_000;
+export function taskTitle(content) {
+    const first = (content ?? '').split('\n')[0] ?? '';
+    return first.trim().slice(0, 80);
+}
+export function matchFeature(arg, tasks) {
+    if (UUID_RE.test(arg)) {
+        return tasks.filter((task) => task.id === arg);
+    }
+    if (SHORT_ID_RE.test(arg)) {
+        return tasks.filter((task) => task.id.startsWith(arg));
+    }
+    const title = arg.trim().toLowerCase();
+    return tasks.filter((task) => task.isFeature && task.title.toLowerCase() === title);
+}
+export async function listTaskSummaries(listTasks) {
+    const summaries = [];
+    for (let offset = 0;; offset += 100) {
+        const page = await listTasks({ limit: 100, offset });
+        for (const item of page.items) {
+            summaries.push({
+                id: item.id,
+                title: taskTitle(item.content),
+                isFeature: item.metadata.kind === 'feature'
+            });
+        }
+        if (offset + 100 >= page.total) {
+            break;
+        }
+    }
+    return summaries;
+}
+export async function runWorktreeNew(feature, options, deps) {
+    const git = (args) => deps.run(args, { cwd: deps.cwd, timeoutMs: GIT_TIMEOUT_MS });
+    const toplevel = await git(['rev-parse', '--show-toplevel']);
+    if (toplevel.ok === false) {
+        throw new AppError(ErrorCode.VALIDATION, 'not in a git repository');
+    }
+    const commonDir = await git([
+        'rev-parse',
+        '--path-format=absolute',
+        '--git-common-dir'
+    ]);
+    if (commonDir.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, 'could not determine the git common dir');
+    }
+    const repoRoot = path.dirname(commonDir.stdout);
+    const tasks = await listTaskSummaries(deps.listTasks);
+    const matches = matchFeature(feature, tasks);
+    if (matches.length > 1) {
+        for (const task of matches) {
+            deps.warn(`${shortId(task.id)} ${task.title}`);
+        }
+        throw new AppError(ErrorCode.CONFLICT, `multiple features match '${feature}'`);
+    }
+    let featureId;
+    let title;
+    if (matches.length === 1) {
+        const match = matches[0];
+        if (match === undefined) {
+            throw new AppError(ErrorCode.INTERNAL, 'no matching feature');
+        }
+        featureId = match.id;
+        title = match.title;
+    }
+    else {
+        if (!options.create) {
+            const confirmed = await deps.confirm(`Create feature "${feature}"?`);
+            if (!confirmed) {
+                throw new AppError(ErrorCode.NOT_FOUND, `no feature matches '${feature}'`);
+            }
+        }
+        const created = await deps.client.createFeature({ content: feature });
+        featureId = created.entity.id;
+        title = taskTitle(feature);
+    }
+    const short = shortId(featureId);
+    const name = slug(title);
+    const branch = `feat/${short}-${name}`;
+    const worktreePath = options.path !== undefined
+        ? path.resolve(deps.cwd, options.path)
+        : path.join(deps.config.worktreeRoot ?? `${repoRoot}.worktrees`, `${short}-${name}`);
+    if (deps.exists(worktreePath)) {
+        throw new UsageError(`worktree path already exists: ${worktreePath}`);
+    }
+    const branchExists = await git([
+        'rev-parse',
+        '--verify',
+        '--quiet',
+        `refs/heads/${branch}`
+    ]);
+    if (branchExists.ok) {
+        throw new UsageError(`branch already exists: ${branch}`);
+    }
+    const originHead = await git([
+        'rev-parse',
+        '--verify',
+        '--quiet',
+        'refs/remotes/origin/HEAD'
+    ]);
+    const base = options.base ?? (originHead.ok ? 'origin/HEAD' : 'HEAD');
+    const add = await git([
+        'worktree',
+        'add',
+        '-b',
+        branch,
+        worktreePath,
+        base
+    ]);
+    if (add.ok === false) {
+        throw new AppError(ErrorCode.INTERNAL, `git worktree add failed${add.timedOut ? ' (timed out)' : ''} (branch: ${branch}, base: ${base})`);
+    }
+    await deps.writeMarker(worktreePath, featureId);
+    const local = await deps.resolveWorkspace(worktreePath);
+    if (local.kind === 'timeout') {
+        deps.warn('git timed out; skipping the workspace report');
+    }
+    else {
+        try {
+            await deps.client.report({
+                source: 'hook',
+                machine: {
+                    alias: deps.config.alias,
+                    hostname: deps.hostname,
+                    boot_id: await deps.bootId()
+                },
+                workspace: local.workspace,
+                feature_id: featureId
+            });
+        }
+        catch (error) {
+            deps.warn(`report failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+    return [worktreePath];
+}
+async function promptConfirm(question) {
+    process.stderr.write(`${question} [y/N] `);
+    const answer = (await readStdinText()).trim().toLowerCase();
+    return answer === 'y' || answer === 'yes';
+}
+export function registerWorktreeCommand(program) {
+    const worktree = usageExit(program
+        .command('worktree')
+        .description('Manage feature worktrees'));
+    const newCommand = usageExit(worktree
+        .command('new <feature>')
+        .description('Create a worktree for a feature (creating it with --create or when confirmed)')
+        .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'));
+    newCommand.action(async (feature) => {
+        const opts = newCommand.opts();
+        await runTrackingCommand(newCommand, async (context) => {
+            const paths = await runWorktreeNew(feature, {
+                create: opts.create === true,
+                ...(opts.base !== undefined ? { base: opts.base } : {}),
+                ...(opts.path !== undefined ? { path: opts.path } : {})
+            }, {
+                client: context.client,
+                config: context.config,
+                cwd: process.cwd(),
+                hostname: os.hostname(),
+                listTasks: (input) => context.pgm.listTasks(input),
+                run: runGit,
+                exists: existsSync,
+                confirm: promptConfirm,
+                bootId: readBootId,
+                resolveWorkspace: (cwd) => resolveLocalWorkspace(cwd),
+                writeMarker,
+                warn: (line) => process.stderr.write(`${line}\n`)
+            });
+            return context.json ? { path: paths[0] ?? '' } : paths;
+        });
+    });
+}