@shepai/cli 1.142.1 → 1.144.0

package/dist/src/presentation/cli/commands/feat/ls.command.d.ts

@@ -1,8 +1,8 @@
 /**
  * Feature List Command
  *
- * Lists features in a formatted list with optional filtering.
- * Derives real-time status from the agent run (not stale Feature.lifecycle).
+ * Lists features in a hierarchical tree view: repo → feature → child → child…
+ * Repos and features are ordered by creation date descending.
  *
  * Usage: shep feat ls [options]
  *
@@ -11,5 +11,47 @@
  * $ shep feat ls --repo /path/to/project
  */
 import { Command } from 'commander';
+import type { Feature, AgentRun, PhaseTiming, Repository } from '../../../../../packages/core/src/domain/generated/output.js';
+/** Convert a date value (any type from domain) to a timestamp for sorting. */
+export declare function toTimestamp(val: unknown): number;
+interface Entry {
+    feature: Feature;
+    run: AgentRun | null;
+    phases: PhaseTiming[];
+}
+interface TreeNode {
+    entry: Entry;
+    children: TreeNode[];
+}
+interface RepoGroup {
+    repoPath: string;
+    repoName: string;
+    repoCreatedAt: number;
+    roots: TreeNode[];
+}
+interface FlatRow {
+    entry: Entry;
+    parentIsLast: boolean[];
+    isLast: boolean;
+}
+/**
+ * Build a recursive feature tree within a single repo group.
+ * Features with a parentId that matches another feature in the group become children.
+ * All levels are sorted by createdAt descending.
+ */
+export declare function buildTree(entries: Entry[]): TreeNode[];
+/**
+ * Group entries by repositoryPath and sort repos by createdAt desc.
+ * Uses the Repository entity's createdAt if available; falls back to the
+ * newest feature's createdAt in that repo group.
+ */
+export declare function groupByRepo(entries: Entry[], repos: Repository[]): RepoGroup[];
+/** Flatten a tree into rows with prefix context for rendering. */
+export declare function flattenTree(nodes: TreeNode[], parentIsLast: boolean[]): FlatRow[];
+/** Build the tree-drawing prefix string for a given depth context. */
+export declare function buildTreePrefix(parentIsLast: boolean[], isLast: boolean): string;
+/** Render a single feature row as a formatted string. */
+export declare function renderFeatureRow(entry: Entry, treePrefix: string): string;
 export declare function createLsCommand(): Command;
+export {};
 //# sourceMappingURL=ls.command.d.ts.map

package/dist/src/presentation/cli/commands/feat/ls.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkLpC,wBAAgB,eAAe,IAAI,OAAO,CAwGzC"}
+{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAyJ/F,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAOhD;AAiBD,UAAU,KAAK;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,UAAU,QAAQ;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,QAAQ,EAAE,CAAC;CACtB;AAED,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,OAAO,EAAE,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,QAAQ,EAAE,CAgCtD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,SAAS,EAAE,CA8B9E;AAED,kEAAkE;AAClE,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAWjF;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,YAAY,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAOhF;AAQD,yDAAyD;AACzD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAazE;AAeD,wBAAgB,eAAe,IAAI,OAAO,CAiFzC"}

package/dist/src/presentation/cli/commands/feat/ls.command.js

@@ -1,8 +1,8 @@
 /**
  * Feature List Command
  *
- * Lists features in a formatted list with optional filtering.
- * Derives real-time status from the agent run (not stale Feature.lifecycle).
+ * Lists features in a hierarchical tree view: repo → feature → child → child…
+ * Repos and features are ordered by creation date descending.
  *
  * Usage: shep feat ls [options]
  *
@@ -14,7 +14,7 @@ import path from 'node:path';
 import { Command } from 'commander';
 import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
 import { ListFeaturesUseCase } from '../../../../../packages/core/src/application/use-cases/features/list-features.use-case.js';
-import { colors, symbols, messages, renderListView } from '../../ui/index.js';
+import { colors, symbols, messages, fmt } from '../../ui/index.js';
 /** Map graph node names to human-readable phase labels (active). */
 const NODE_TO_PHASE = {
     analyze: 'Analyzing',
@@ -33,21 +33,10 @@ const NODE_TO_REVIEW = {
     implement: 'Review Merge',
     merge: 'Review Merge',
 };
-/** Status priority for sorting (lower = higher priority). */
-const STATUS_PRIORITY = {
-    running: 0,
-    pending: 0,
-    waiting_approval: 1,
-    failed: 2,
-    interrupted: 2,
-    completed: 3,
-};
 /**
  * Derive the display status from the agent run.
- * Returns the current graph node as a phase label with an activity indicator.
  */
 function formatStatus(feature, run) {
-    // Blocked features show "Waiting" — the parent relationship is conveyed by tree indentation
     if (feature.lifecycle === 'Archived') {
         return `${colors.muted(symbols.dotEmpty)} ${colors.muted('Archived')}`;
     }
@@ -124,7 +113,6 @@ function formatElapsed(run, phaseTimings) {
         const totalMs = phaseTimings.reduce((sum, pt) => {
             if (pt.durationMs != null)
                 return sum + Number(pt.durationMs);
-            // Phase still running — add live delta
             if (pt.startedAt)
                 return sum + (now - new Date(pt.startedAt).getTime());
             return sum;
@@ -132,7 +120,6 @@ function formatElapsed(run, phaseTimings) {
         const isRunning = run?.status === 'running' || run?.status === 'pending';
         return isRunning ? colors.info(formatDuration(totalMs)) : colors.muted(formatDuration(totalMs));
     }
-    // Fallback to run timestamps if no phase timings
     if (!run?.startedAt)
         return '';
     const started = new Date(run.startedAt).getTime();
@@ -160,11 +147,149 @@ function formatGates(feature) {
     const push = feature.push ? colors.accent('■') : colors.muted('□');
     return `${gate(allowPrd)} ${gate(allowPlan)} ${gate(allowMerge)} ${push}`;
 }
-/** Get sort priority for a run status (lower = shown first). */
-function getStatusPriority(run) {
-    if (!run)
-        return 4;
-    return STATUS_PRIORITY[run.status] ?? 4;
+/** Convert a date value (any type from domain) to a timestamp for sorting. */
+export function toTimestamp(val) {
+    if (!val)
+        return 0;
+    try {
+        return new Date(val).getTime();
+    }
+    catch {
+        return 0;
+    }
+}
+/** Strip ANSI escape sequences to get visible character count. */
+function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1B\[[0-9;]*m/g, '');
+}
+/** Pad a string that may contain ANSI codes to a given visible width. */
+function ansiPad(text, width) {
+    const visible = stripAnsi(text).length;
+    if (visible >= width)
+        return text;
+    return text + ' '.repeat(width - visible);
+}
+/**
+ * Build a recursive feature tree within a single repo group.
+ * Features with a parentId that matches another feature in the group become children.
+ * All levels are sorted by createdAt descending.
+ */
+export function buildTree(entries) {
+    const byId = new Map();
+    for (const e of entries)
+        byId.set(e.feature.id, e);
+    const childrenByParent = new Map();
+    const rootEntries = [];
+    for (const e of entries) {
+        const pid = e.feature.parentId;
+        if (pid && byId.has(pid)) {
+            const list = childrenByParent.get(pid) ?? [];
+            list.push(e);
+            childrenByParent.set(pid, list);
+        }
+        else {
+            rootEntries.push(e);
+        }
+    }
+    function sortDesc(arr) {
+        return [...arr].sort((a, b) => toTimestamp(b.feature.createdAt) - toTimestamp(a.feature.createdAt));
+    }
+    function buildNodes(arr) {
+        return sortDesc(arr).map((e) => ({
+            entry: e,
+            children: buildNodes(childrenByParent.get(e.feature.id) ?? []),
+        }));
+    }
+    return buildNodes(rootEntries);
+}
+/**
+ * Group entries by repositoryPath and sort repos by createdAt desc.
+ * Uses the Repository entity's createdAt if available; falls back to the
+ * newest feature's createdAt in that repo group.
+ */
+export function groupByRepo(entries, repos) {
+    const repoByPath = new Map();
+    for (const r of repos) {
+        repoByPath.set(r.path.replace(/\\/g, '/'), r);
+    }
+    const groupMap = new Map();
+    for (const e of entries) {
+        const repoPath = e.feature.repositoryPath.replace(/\\/g, '/');
+        const list = groupMap.get(repoPath) ?? [];
+        list.push(e);
+        groupMap.set(repoPath, list);
+    }
+    const groups = [];
+    for (const [repoPath, groupEntries] of groupMap) {
+        const repo = repoByPath.get(repoPath);
+        const repoCreatedAt = repo
+            ? toTimestamp(repo.createdAt)
+            : Math.max(...groupEntries.map((e) => toTimestamp(e.feature.createdAt)));
+        groups.push({
+            repoPath,
+            repoName: path.basename(repoPath),
+            repoCreatedAt,
+            roots: buildTree(groupEntries),
+        });
+    }
+    groups.sort((a, b) => b.repoCreatedAt - a.repoCreatedAt);
+    return groups;
+}
+/** Flatten a tree into rows with prefix context for rendering. */
+export function flattenTree(nodes, parentIsLast) {
+    const result = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const isLast = i === nodes.length - 1;
+        result.push({ entry: node.entry, parentIsLast, isLast });
+        if (node.children.length > 0) {
+            result.push(...flattenTree(node.children, [...parentIsLast, isLast]));
+        }
+    }
+    return result;
+}
+/** Build the tree-drawing prefix string for a given depth context. */
+export function buildTreePrefix(parentIsLast, isLast) {
+    let prefix = '';
+    for (const wasLast of parentIsLast) {
+        prefix += wasLast ? '   ' : '│  ';
+    }
+    prefix += isLast ? '└─ ' : '├─ ';
+    return prefix;
+}
+// Column widths for feature rows
+const FIRST_COL_WIDTH = 44; // tree prefix + id + 2 spaces + name
+const STATUS_WIDTH = 22;
+const GATES_WIDTH = 10;
+const ELAPSED_WIDTH = 9;
+/** Render a single feature row as a formatted string. */
+export function renderFeatureRow(entry, treePrefix) {
+    const { feature, run, phases } = entry;
+    const shortId = colors.muted(feature.id.slice(0, 8));
+    const prefixPlusId = `${treePrefix}${shortId}  `;
+    const prefixPlusIdLen = stripAnsi(prefixPlusId).length;
+    const nameMax = Math.max(FIRST_COL_WIDTH - prefixPlusIdLen, 8);
+    const name = truncate(feature.name, nameMax);
+    const firstCol = ansiPad(prefixPlusId + name, FIRST_COL_WIDTH);
+    const status = ansiPad(formatStatus(feature, run), STATUS_WIDTH);
+    const gates = ansiPad(formatGates(feature), GATES_WIDTH);
+    const elapsed = ansiPad(formatElapsed(run, phases), ELAPSED_WIDTH);
+    const done = formatDone(run);
+    return `  ${firstCol}  ${status}  ${gates}  ${elapsed}  ${done}`;
+}
+/** Count total features across all repo groups. */
+function countFeatures(groups) {
+    let count = 0;
+    function countNodes(nodes) {
+        for (const n of nodes) {
+            count++;
+            countNodes(n.children);
+        }
+    }
+    for (const g of groups)
+        countNodes(g.roots);
+    return count;
 }
 export function createLsCommand() {
     return new Command('ls')
@@ -177,79 +302,54 @@ export function createLsCommand() {
             const useCase = container.resolve(ListFeaturesUseCase);
             const runRepo = container.resolve('IAgentRunRepository');
             const phaseRepo = container.resolve('IPhaseTimingRepository');
+            const repoRepo = container.resolve('IRepositoryRepository');
             const filters = {
                 ...(options.repo && { repositoryPath: options.repo }),
                 ...(options.includeDeleted && { includeDeleted: true }),
                 ...(options.showArchived && { includeArchived: true }),
             };
             const features = await useCase.execute(Object.keys(filters).length > 0 ? filters : undefined);
-            // Load agent runs and phase timings for all features in parallel
-            const [runs, timings] = await Promise.all([
+            // Load agent runs, phase timings, and repos in parallel
+            const [runs, timings, repos] = await Promise.all([
                 Promise.all(features.map((f) => f.agentRunId ? runRepo.findById(f.agentRunId) : Promise.resolve(null))),
                 Promise.all(features.map((f) => phaseRepo.findByFeatureId(f.id))),
+                repoRepo.list(),
             ]);
-            // Pair features with runs/timings and sort by status priority
-            const paired = features
-                .map((feature, i) => ({ feature, run: runs[i], phases: timings[i] }))
-                .sort((a, b) => getStatusPriority(a.run) - getStatusPriority(b.run));
-            const childrenByParent = new Map();
-            const roots = [];
-            for (const entry of paired) {
-                const pid = entry.feature.parentId;
-                if (pid && entry.feature.lifecycle === 'Blocked') {
-                    const list = childrenByParent.get(pid) ?? [];
-                    list.push(entry);
-                    childrenByParent.set(pid, list);
-                }
-                else {
-                    roots.push(entry);
-                }
-            }
-            // Flatten: parent then its blocked children
-            const ordered = [];
-            for (const entry of roots) {
-                ordered.push({ entry, indent: false });
-                const kids = childrenByParent.get(entry.feature.id);
-                if (kids) {
-                    for (const kid of kids) {
-                        ordered.push({ entry: kid, indent: true });
-                    }
-                    childrenByParent.delete(entry.feature.id);
-                }
+            const entries = features.map((feature, i) => ({
+                feature,
+                run: runs[i],
+                phases: timings[i],
+            }));
+            const groups = groupByRepo(entries, repos);
+            const total = countFeatures(groups);
+            if (total === 0) {
+                messages.newline();
+                messages.info('No features found');
+                messages.newline();
+                return;
             }
-            // Append orphaned blocked children (parent not in current list)
-            for (const kids of childrenByParent.values()) {
-                for (const kid of kids) {
-                    ordered.push({ entry: kid, indent: false });
+            const lines = [];
+            lines.push('');
+            lines.push(`  ${fmt.heading(`Features (${total})`)}`);
+            lines.push('');
+            // Column headers
+            const h1 = colors.muted('NAME'.padEnd(FIRST_COL_WIDTH));
+            const h2 = colors.muted('STATUS'.padEnd(STATUS_WIDTH));
+            const h3 = colors.muted('R P M ↑'.padEnd(GATES_WIDTH));
+            const h4 = colors.muted('ELAPSED'.padEnd(ELAPSED_WIDTH));
+            const h5 = colors.muted('DONE');
+            lines.push(`  ${h1}  ${h2}  ${h3}  ${h4}  ${h5}`);
+            for (const group of groups) {
+                lines.push('');
+                lines.push(`  ${fmt.heading(group.repoName)}  ${colors.muted(group.repoPath)}`);
+                const flatRows = flattenTree(group.roots, []);
+                for (const { entry, parentIsLast, isLast } of flatRows) {
+                    const treePrefix = buildTreePrefix(parentIsLast, isLast);
+                    lines.push(renderFeatureRow(entry, treePrefix));
                 }
             }
-            const rows = ordered.map(({ entry: { feature, run, phases }, indent }) => {
-                const repo = path.basename(feature.repositoryPath);
-                const prefix = indent ? `${colors.muted('└')} ` : '';
-                return [
-                    prefix + feature.id.slice(0, 8),
-                    prefix + truncate(feature.name, indent ? 28 : 30),
-                    formatStatus(feature, run),
-                    colors.muted(repo),
-                    formatGates(feature),
-                    formatElapsed(run, phases),
-                    formatDone(run),
-                ];
-            });
-            renderListView({
-                title: 'Features',
-                columns: [
-                    { label: 'ID', width: 10 },
-                    { label: 'Name', width: 32 },
-                    { label: 'Status', width: 21 },
-                    { label: 'Repo', width: 20 },
-                    { label: 'R P M ↑', width: 10 },
-                    { label: 'Elapsed', width: 10 },
-                    { label: 'Done', width: 12 },
-                ],
-                rows,
-                emptyMessage: 'No features found',
-            });
+            lines.push('');
+            console.log(lines.join('\n'));
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));