@ivotoby/postgram-cli 1.38.3 → 1.39.0

package/dist/tracking/local.js

@@ -0,0 +1,175 @@
+// cli/src/tracking/local.ts: local machine/workspace resolution (research R6-R8).
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const runGit = (args, options) => new Promise((resolve) => {
+    execFile('git', args, {
+        cwd: options.cwd,
+        timeout: options.timeoutMs,
+        env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' }
+    }, (error, stdout) => {
+        if (error !== null) {
+            resolve({ ok: false, timedOut: error.killed === true });
+        }
+        else {
+            resolve({ ok: true, stdout: stdout.replace(/\n$/, '') });
+        }
+    });
+});
+function parseCount(stdout) {
+    const value = Number.parseInt(stdout.trim(), 10);
+    return Number.isSafeInteger(value) ? value : null;
+}
+export async function resolveLocalWorkspace(cwd, options) {
+    const budgetMs = options?.budgetMs ?? 800;
+    const run = options?.run ?? runGit;
+    const startedAt = Date.now();
+    const nextTimeoutMs = () => Math.max(1, Math.min(500, budgetMs - (Date.now() - startedAt)));
+    const toplevel = await run(['rev-parse', '--show-toplevel'], {
+        cwd,
+        timeoutMs: nextTimeoutMs()
+    });
+    if (toplevel.ok === false) {
+        if (toplevel.timedOut) {
+            return { kind: 'timeout' };
+        }
+        const outside = await realpath(cwd);
+        return {
+            kind: 'ok',
+            path: outside,
+            repoRoot: null,
+            workspace: { path: outside, git: null }
+        };
+    }
+    const root = await realpath(toplevel.stdout);
+    const commonDir = run(['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: root, timeoutMs: nextTimeoutMs() });
+    const branch = run(['symbolic-ref', '--short', '-q', 'HEAD'], {
+        cwd: root,
+        timeoutMs: nextTimeoutMs()
+    });
+    const remote = run(['remote', 'get-url', 'origin'], {
+        cwd: root,
+        timeoutMs: nextTimeoutMs()
+    });
+    const status = run(['status', '--porcelain=v1', '--untracked-files=normal'], { cwd: root, timeoutMs: nextTimeoutMs() });
+    const upstream = run(['rev-list', '--count', '@{upstream}..HEAD'], {
+        cwd: root,
+        timeoutMs: nextTimeoutMs()
+    });
+    const [commonDirResult, branchResult, remoteResult, statusResult, upstreamResult] = await Promise.all([commonDir, branch, remote, status, upstream]);
+    const workspace = { path: root };
+    let repoRoot = null;
+    if (commonDirResult.ok) {
+        repoRoot = path.dirname(commonDirResult.stdout);
+        workspace.repo_root = repoRoot;
+    }
+    if (branchResult.ok) {
+        workspace.branch = branchResult.stdout === '' ? null : branchResult.stdout;
+    }
+    else if (branchResult.timedOut === false) {
+        workspace.branch = null;
+    }
+    if (remoteResult.ok) {
+        workspace.repo_remote = remoteResult.stdout;
+    }
+    else if (remoteResult.timedOut === false) {
+        workspace.repo_remote = null;
+    }
+    let git = null;
+    if (statusResult.ok) {
+        const dirtyCount = statusResult.stdout
+            .split('\n')
+            .filter((line) => line !== '')
+            .length;
+        if (upstreamResult.ok) {
+            const unpushed = parseCount(upstreamResult.stdout);
+            if (unpushed !== null) {
+                git = { dirty_count: dirtyCount, unpushed_count: unpushed, has_upstream: true };
+            }
+        }
+        else if (upstreamResult.timedOut === false) {
+            const fallback = await run(['rev-list', '--count', 'HEAD', '--not', '--remotes'], { cwd: root, timeoutMs: nextTimeoutMs() });
+            if (fallback.ok) {
+                const unpushed = parseCount(fallback.stdout);
+                if (unpushed !== null) {
+                    git = { dirty_count: dirtyCount, unpushed_count: unpushed, has_upstream: false };
+                }
+            }
+        }
+    }
+    if (git !== null) {
+        workspace.git = git;
+    }
+    return { kind: 'ok', path: root, repoRoot, workspace };
+}
+function defaultExec(cmd, args) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, (error, stdout) => {
+            if (error !== null) {
+                reject(error instanceof Error ? error : new Error('exec failed'));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+export async function readBootId(options) {
+    const platform = options?.platform ?? process.platform;
+    const readFileFn = options?.readFile ?? ((file) => readFile(file, 'utf8'));
+    const execFn = options?.exec ?? defaultExec;
+    try {
+        if (platform === 'linux') {
+            return (await readFileFn('/proc/sys/kernel/random/boot_id')).trim();
+        }
+        if (platform === 'darwin') {
+            const output = await execFn('sysctl', ['-n', 'kern.boottime']);
+            const match = output.match(/\{[^}]*\}/);
+            if (match === null || match[0] === undefined) {
+                return null;
+            }
+            return createHash('sha256').update(match[0]).digest('hex');
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export const MARKER_DIR = '.postgram';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function markerFile(worktree) {
+    return path.join(worktree, MARKER_DIR, 'feature.json');
+}
+export async function readMarker(worktree) {
+    let text;
+    try {
+        text = await readFile(markerFile(worktree), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const id = parsed.feature_id;
+    return typeof id === 'string' && UUID_RE.test(id) ? id : null;
+}
+export async function writeMarker(worktree, featureId, now) {
+    const dir = path.join(worktree, MARKER_DIR);
+    await mkdir(dir, { recursive: true });
+    const createdAt = (now ?? new Date()).toISOString();
+    await writeFile(path.join(dir, 'feature.json'), `${JSON.stringify({ feature_id: featureId, created_at: createdAt }, null, 2)}\n`, 'utf8');
+    await writeFile(path.join(dir, '.gitignore'), '*\n', 'utf8');
+}
+export async function removeMarker(worktree) {
+    await rm(markerFile(worktree), { force: true });
+}

package/dist/tracking/resume.js

@@ -0,0 +1,43 @@
+// cli/src/tracking/resume.ts
+import { shq } from './config.js';
+export function resumeDirectory(workspace) {
+    const cwd = workspace.resume_session?.cwd ?? null;
+    if (cwd !== null && (cwd === workspace.path || cwd.startsWith(`${workspace.path}/`))) {
+        return cwd;
+    }
+    return workspace.path;
+}
+export function isTranscriptGone(workspace, localAlias, exists) {
+    const session = workspace.resume_session;
+    return (workspace.machine === localAlias &&
+        session !== null &&
+        session.agent_kind === 'claude-code' &&
+        session.transcript_path !== null &&
+        !exists(session.transcript_path));
+}
+export function renderResume(workspace, input) {
+    const session = workspace.resume_session;
+    const first = workspace.sessions[0];
+    const kind = session?.agent_kind ?? first?.agent_kind ?? 'claude-code';
+    const withId = session ? input.templates[session.agent_kind].with_id : null;
+    const tpl = session !== null && withId !== null && !input.transcriptGone
+        ? withId.replaceAll('{session_id}', shq(session.agent_session_id))
+        : input.templates[kind].without_id;
+    const local = `cd ${shq(resumeDirectory(workspace))}${tpl ? ` && ${tpl}` : ''}`;
+    if (workspace.machine === input.localAlias) {
+        return local;
+    }
+    return `ssh -t ${workspace.connect_target} ${shq(local)}`;
+}
+export function formatAge(fromIso, now) {
+    const elapsedMs = Math.max(0, now.getTime() - Date.parse(fromIso));
+    const minutes = Math.floor(elapsedMs / 60_000);
+    if (minutes < 60) {
+        return `${minutes}m`;
+    }
+    const hours = Math.floor(elapsedMs / 3_600_000);
+    if (hours < 48) {
+        return `${hours}h`;
+    }
+    return `${Math.floor(elapsedMs / 86_400_000)}d`;
+}

package/dist/tracking/scan-discovery.js

@@ -0,0 +1,295 @@
+// cli/src/tracking/scan-discovery.ts: pgm scan repository and session discovery (research R9).
+import { readFile, readdir, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { runGit } from './local.js';
+async function isDirectory(file) {
+    try {
+        return (await stat(file)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function hasGitEntry(dir) {
+    try {
+        await stat(path.join(dir, '.git'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function findRepositories(roots, depth) {
+    const found = new Set();
+    const visit = async (dir, level) => {
+        if (await hasGitEntry(dir)) {
+            found.add(await realpath(dir));
+            return;
+        }
+        if (level >= depth) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (name === 'node_modules' || name.startsWith('.')) {
+                continue;
+            }
+            const child = path.join(dir, name);
+            if (await isDirectory(child)) {
+                await visit(child, level + 1);
+            }
+        }
+    };
+    for (const root of roots) {
+        let resolved;
+        try {
+            resolved = await realpath(root);
+        }
+        catch {
+            continue;
+        }
+        if (!(await isDirectory(resolved))) {
+            continue;
+        }
+        await visit(resolved, 0);
+    }
+    return [...found].sort();
+}
+export async function listWorktrees(repo, run) {
+    const runner = run ?? runGit;
+    const result = await runner(['worktree', 'list', '--porcelain'], {
+        cwd: repo,
+        timeoutMs: 5000
+    });
+    if (!result.ok) {
+        return [];
+    }
+    const out = [];
+    for (const block of result.stdout.split('\n\n')) {
+        const trimmed = block.trim();
+        if (trimmed === '') {
+            continue;
+        }
+        let worktree = null;
+        let branch = null;
+        let bare = false;
+        for (const line of trimmed.split('\n')) {
+            if (line.startsWith('worktree ')) {
+                worktree = line.slice('worktree '.length);
+            }
+            else if (line.startsWith('branch refs/heads/')) {
+                branch = line.slice('branch refs/heads/'.length);
+            }
+            else if (line === 'bare') {
+                bare = true;
+            }
+        }
+        if (worktree === null || bare) {
+            continue;
+        }
+        if (!(await isDirectory(worktree))) {
+            continue;
+        }
+        out.push({ path: await realpath(worktree), branch });
+    }
+    return out;
+}
+export async function discoverWorktrees(roots, depth, run) {
+    const repos = await findRepositories(roots, depth);
+    const byPath = new Map();
+    for (const repo of repos) {
+        for (const worktree of await listWorktrees(repo, run)) {
+            byPath.set(worktree.path, worktree);
+        }
+    }
+    return [...byPath.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+export function claudeEncode(value) {
+    return value.replace(/[^a-zA-Z0-9]/g, '-');
+}
+function bySessionId(a, b) {
+    return a.agent_session_id < b.agent_session_id
+        ? -1
+        : a.agent_session_id > b.agent_session_id
+            ? 1
+            : 0;
+}
+function lineCwd(line) {
+    const trimmed = line.trim();
+    if (trimmed === '') {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const cwd = parsed.cwd;
+    return typeof cwd === 'string' ? cwd : null;
+}
+async function claudeSession(transcript, worktree) {
+    let text;
+    try {
+        text = await readFile(transcript, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let cwd = null;
+    for (const line of text.split('\n').slice(0, 200)) {
+        const value = lineCwd(line);
+        if (value !== null) {
+            cwd = value;
+            break;
+        }
+    }
+    if (cwd !== null && cwd !== worktree && !cwd.startsWith(worktree + '/')) {
+        return null;
+    }
+    const mtime = (await stat(transcript)).mtime;
+    return {
+        agent_kind: 'claude-code',
+        agent_session_id: path.basename(transcript, '.jsonl'),
+        cwd,
+        transcript_path: transcript,
+        observed_at: mtime.toISOString()
+    };
+}
+export async function findClaudeSessions(worktrees, claudeDir) {
+    const notes = [];
+    const encs = new Map();
+    for (const worktree of worktrees) {
+        const enc = claudeEncode(worktree);
+        if (enc.length > 200) {
+            notes.push(`skipped ${worktree}: encoded path too long`);
+            continue;
+        }
+        encs.set(worktree, enc);
+    }
+    const sessions = new Map();
+    const projectsDir = path.join(claudeDir, 'projects');
+    let entries;
+    try {
+        entries = await readdir(projectsDir);
+    }
+    catch {
+        return { sessions, notes };
+    }
+    for (const name of entries) {
+        const dir = path.join(projectsDir, name);
+        if (!(await isDirectory(dir))) {
+            continue;
+        }
+        let best = null;
+        let bestLen = -1;
+        for (const [worktree, enc] of encs) {
+            if (name === enc || name.startsWith(enc + '-')) {
+                if (enc.length > bestLen) {
+                    bestLen = enc.length;
+                    best = worktree;
+                }
+            }
+        }
+        if (best === null) {
+            continue;
+        }
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        const found = [];
+        for (const file of files) {
+            if (!file.endsWith('.jsonl')) {
+                continue;
+            }
+            const session = await claudeSession(path.join(dir, file), best);
+            if (session !== null) {
+                found.push(session);
+            }
+        }
+        if (found.length > 0) {
+            const existing = sessions.get(best) ?? [];
+            existing.push(...found);
+            existing.sort(bySessionId);
+            sessions.set(best, existing);
+        }
+    }
+    return { sessions, notes };
+}
+async function piSession(transcript) {
+    let text;
+    try {
+        text = await readFile(transcript, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const first = text.split('\n')[0];
+    if (first === undefined || first.trim() === '') {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(first);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    const header = parsed;
+    if (typeof header.id !== 'string') {
+        return null;
+    }
+    const mtime = (await stat(transcript)).mtime;
+    return {
+        agent_kind: 'pi',
+        agent_session_id: header.id,
+        cwd: typeof header.cwd === 'string' ? header.cwd : null,
+        transcript_path: transcript,
+        observed_at: mtime.toISOString()
+    };
+}
+export async function findPiSessions(worktrees, piDir) {
+    const sessions = new Map();
+    for (const worktree of worktrees) {
+        const dir = path.join(piDir, 'sessions', `--${worktree.replace(/^\/+/, '').replaceAll('/', '-')}--`);
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        const found = [];
+        for (const file of files) {
+            if (!file.endsWith('.jsonl')) {
+                continue;
+            }
+            const session = await piSession(path.join(dir, file));
+            if (session !== null) {
+                found.push(session);
+            }
+        }
+        if (found.length > 0) {
+            found.sort(bySessionId);
+            sessions.set(worktree, found);
+        }
+    }
+    return sessions;
+}