@zenera/cli 1.1.23 → 1.1.25

package/dist/commands/list.js

@@ -1,21 +1,38 @@
+import { join } from 'node:path';
 import { parse } from "../args.js";
 // Run ids are timestamps by construction, so the newest id *is* the last-run
 // time — no file has to be opened to learn it.
 import { stampInstant } from "../ids.js";
-import { openDir, Registry, summarize } from "../projects.js";
-import { listSessions } from "../session.js";
-import { ago, bold, count, dim, json, note, table, write, writeAll, yellow } from "../term.js";
-const USAGE = 'zen list [--sessions] [--prune]';
+import { openDir, Registry, runIds, sessionIds, sessionsDir, summarize, } from "../projects.js";
+import { listSessions, readRunMeta, runPaths, sessionPaths } from "../session.js";
+import { ago, bold, count, cyan, dim, json, note, red, table, usageError, write, writeAll, yellow, } from "../term.js";
+const USAGE = 'zen list [--sessions] [--runs] [--limit <n>] [--prune]';
+/** Recent runs shown before `--limit` is asked for. */
+const RECENT = 20;
 export const list = {
     summary: 'Every known project: sessions, last run, whether one is live.',
     usage: USAGE,
     banner: { head: 'Zenera', accent: 'Projects', subtitle: 'Project Registry', hue: 'sky' },
     details: [
+        "  --sessions             Also list each project's sessions.",
+        '  --runs                 The most recent runs, newest first, across every project.',
+        '  --limit <n>            Runs to list. Default 20.',
+        '  --prune                Forget entries whose directory has gone away.',
+        '',
+        '--runs answers "what ran last", which is not a question about one',
+        'project, so on its own it replaces the table rather than following it.',
+        '',
         'The registry is an index, not the truth. An entry whose directory has',
         'gone away is shown dimmed rather than hidden; --prune forgets them.',
     ],
     run: async (ctx) => {
-        const { values } = parse(ctx.args, { sessions: { type: 'boolean' }, prune: { type: 'boolean' } }, USAGE);
+        const { values } = parse(ctx.args, {
+            sessions: { type: 'boolean' },
+            runs: { type: 'boolean' },
+            limit: { type: 'string' },
+            prune: { type: 'boolean' },
+        }, USAGE);
+        const limit = number(values.limit, '--limit') ?? RECENT;
         const registry = await Registry.open();
         if (values.prune) {
             const gone = registry.prune();
@@ -29,8 +46,18 @@ export const list = {
             summaries.push(await summarize(entry));
         }
         summaries.sort((a, b) => (b.lastRunAt ?? '').localeCompare(a.lastRunAt ?? ''));
+        // `--runs` asks a question about runs, so on its own it *replaces* the
+        // project table rather than following thirty rows of it. Asked together
+        // with `--sessions`, both are wanted and both are printed.
+        const projectTable = !values.runs || values.sessions;
         if (ctx.json) {
-            json(values.sessions ? await withSessions(summaries) : summaries);
+            const runs = values.runs ? await recent(summaries, limit).runs : undefined;
+            if (!projectTable) {
+                json(runs);
+                return;
+            }
+            const projects = values.sessions ? await withSessions(summaries) : summaries;
+            json(runs ? { projects, runs } : projects);
             return;
         }
         if (summaries.length === 0) {
@@ -38,20 +65,22 @@ export const list = {
             note(dim('create one: zen init'));
             return;
         }
-        const rows = [
-            [bold('NAME'), bold('SESSIONS'), bold('RUNS'), bold('LAST'), bold('PATH')],
-        ];
-        for (const s of summaries) {
-            const style = s.present ? (x) => x : dim;
-            rows.push([
-                style(s.name) + (s.busy ? yellow(' •') : ''),
-                style(String(s.sessions)),
-                style(String(s.runs)),
-                style(ago(s.lastRunAt ? stampInstant(s.lastRunAt) : undefined)),
-                dim(s.present ? s.path : `${s.path} (missing)`),
-            ]);
+        if (projectTable) {
+            const rows = [
+                [bold('NAME'), bold('SESSIONS'), bold('RUNS'), bold('LAST'), bold('PATH')],
+            ];
+            for (const s of summaries) {
+                const style = s.present ? (x) => x : dim;
+                rows.push([
+                    style(s.name) + (s.busy ? yellow(' •') : ''),
+                    style(String(s.sessions)),
+                    style(String(s.runs)),
+                    style(ago(s.lastRunAt ? stampInstant(s.lastRunAt) : undefined)),
+                    dim(s.present ? s.path : `${s.path} (missing)`),
+                ]);
+            }
+            writeAll(table(rows));
         }
-        writeAll(table(rows));
         if (values.sessions) {
             for (const s of summaries.filter((p) => p.present)) {
                 write('');
@@ -59,8 +88,88 @@ export const list = {
                 writeAll(await sessionRows(s));
             }
         }
+        if (values.runs) {
+            if (projectTable) {
+                write('');
+            }
+            await writeRuns(summaries, limit);
+        }
     },
 };
+function keys(summaries) {
+    const out = [];
+    for (const project of summaries) {
+        if (!project.present) {
+            continue;
+        }
+        for (const session of sessionIds(project.path)) {
+            for (const id of runIds(join(sessionsDir(project.path), session))) {
+                out.push({ project, session, id });
+            }
+        }
+    }
+    return out.sort((a, b) => b.id.localeCompare(a.id));
+}
+function recent(summaries, limit) {
+    const all = keys(summaries);
+    const runs = Promise.all(all.slice(0, limit).map(async (k) => {
+        const run = runPaths(sessionPaths(k.project.path, k.session), k.id);
+        const meta = await readRunMeta(run);
+        return {
+            id: k.id,
+            project: k.project.name,
+            session: k.session,
+            dir: run.dir,
+            startedAt: meta.startedAt ?? stampInstant(k.id),
+            finishedAt: meta.finishedAt,
+            agent: meta.agent,
+            stopReason: meta.stopReason,
+            error: meta.error,
+        };
+    }));
+    return { runs, found: all.length };
+}
+async function writeRuns(summaries, limit) {
+    const { runs, found } = recent(summaries, limit);
+    const rows = await runs;
+    if (rows.length === 0) {
+        note('no runs yet');
+        note(dim('start one: zen run'));
+        return;
+    }
+    writeAll(table([
+        [
+            bold('RUN'),
+            bold('PROJECT'),
+            bold('SESSION'),
+            bold('AGENT'),
+            bold('OUTCOME'),
+            bold('WHEN'),
+        ],
+        ...rows.map((r) => [
+            r.id,
+            cyan(r.project),
+            dim(r.session),
+            r.agent ?? dim('—'),
+            r.error ? red('failed') : (r.stopReason ?? dim('—')),
+            ago(r.finishedAt ?? r.startedAt),
+        ]),
+    ]));
+    if (found > rows.length) {
+        note('');
+        note(dim(`${found - rows.length} more — raise --limit to see them`));
+    }
+}
+function number(text, flag) {
+    if (text === undefined) {
+        return undefined;
+    }
+    const value = Number(text);
+    if (!Number.isInteger(value) || value < 1) {
+        throw usageError(`${flag} takes a whole number of at least 1`, `got "${text}"`);
+    }
+    return value;
+}
 /**
  * Run ids are timestamps by construction, so the newest id *is* the last-run
  * time — no file has to be opened to learn it.