bet-cli 0.1.0

package/dist/ui/prompt.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { SelectList } from './select.js';
+import { SearchSelect } from './search.js';
+export async function promptSelect(items, options = {}) {
+    return new Promise((resolve) => {
+        const { unmount } = render(_jsx(SelectList, { title: options.title, items: items, maxRows: options.maxRows, onSelect: (item) => {
+                unmount();
+                resolve(item);
+            }, onCancel: () => {
+                unmount();
+                resolve(undefined);
+            } }), {
+            stdout: process.stderr,
+        });
+    });
+}
+export async function promptSearch(items, options) {
+    return new Promise((resolve) => {
+        const { unmount } = render(_jsx(SearchSelect, { title: options.title, allItems: items, filter: options.filter, maxRows: options.maxRows, initialQuery: options.initialQuery, onSelect: (item) => {
+                unmount();
+                resolve(item);
+            }, onCancel: () => {
+                unmount();
+                resolve(undefined);
+            } }), {
+            stdout: process.stderr,
+        });
+    });
+}

package/dist/ui/search.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import chalk from 'chalk';
+import { Box, Text, useInput } from 'ink';
+const DEFAULT_MAX_ROWS = 18;
+export function SearchSelect({ title, allItems, filter, onSelect, onCancel, maxRows = DEFAULT_MAX_ROWS, initialQuery = '', showCount = true, }) {
+    const [cursor, setCursor] = useState(0);
+    const [query, setQuery] = useState(initialQuery);
+    const items = useMemo(() => filter(allItems, query), [allItems, filter, query]);
+    useInput((input, key) => {
+        if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel?.();
+            return;
+        }
+        if (key.return) {
+            const entry = items[cursor];
+            if (entry)
+                onSelect(entry);
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setCursor((prev) => (prev - 1 + items.length) % Math.max(items.length, 1));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setCursor((prev) => (prev + 1) % Math.max(items.length, 1));
+            return;
+        }
+        if (input === '\b' || input === '\x7f') {
+            setQuery((prev) => prev.slice(0, -1));
+            setCursor(0);
+            return;
+        }
+        if (input) {
+            setQuery((prev) => prev + input);
+            setCursor(0);
+        }
+    });
+    if (items.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { children: chalk.bold(title) }), _jsx(Text, { children: `Search: ${query}` }), _jsx(Text, { children: "No results." })] }));
+    }
+    const selectedRowIndex = Math.min(cursor, items.length - 1);
+    const totalRows = items.length;
+    const effectiveMaxRows = Math.max(3, maxRows);
+    const windowStart = Math.min(Math.max(0, selectedRowIndex - Math.floor(effectiveMaxRows / 2)), Math.max(0, totalRows - effectiveMaxRows));
+    const windowEnd = Math.min(totalRows, windowStart + effectiveMaxRows);
+    const windowed = items.slice(windowStart, windowEnd);
+    return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { children: chalk.bold(title) }), _jsx(Text, { children: `Search: ${query}` }), showCount && _jsx(Text, { children: chalk.dim(`${items.length} result(s)`) }), windowed.map((row, idx) => {
+                const absoluteIndex = windowStart + idx;
+                const selected = absoluteIndex === selectedRowIndex;
+                return (_jsxs(Box, { children: [_jsxs(Text, { children: [selected ? chalk.cyan.bold('› ') : '  ', selected ? chalk.cyan.bold(row.label) : row.label] }), row.hint ? _jsx(Text, { children: chalk.dim(` ${row.hint}`) }) : null] }, `item-${absoluteIndex}`));
+            }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: chalk.dim('Type to filter. Use ↑/↓ or j/k. Enter to select. Esc to cancel.') }) })] }));
+}

package/dist/ui/select.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import chalk from 'chalk';
+import { Box, Text, useInput } from 'ink';
+const DEFAULT_MAX_ROWS = 18;
+export function SelectList({ title, items, onSelect, onCancel, maxRows = DEFAULT_MAX_ROWS, }) {
+    const selectableIndices = useMemo(() => items.map((item, index) => (item.type === 'item' ? index : -1)).filter((idx) => idx >= 0), [items]);
+    const [cursor, setCursor] = useState(0);
+    useInput((input, key) => {
+        if (selectableIndices.length === 0) {
+            if (key.escape || (key.ctrl && input === 'c')) {
+                onCancel?.();
+            }
+            return;
+        }
+        if (key.upArrow || input === 'k') {
+            setCursor((prev) => (prev - 1 + selectableIndices.length) % selectableIndices.length);
+        }
+        else if (key.downArrow || input === 'j') {
+            setCursor((prev) => (prev + 1) % selectableIndices.length);
+        }
+        else if (key.return) {
+            const itemIndex = selectableIndices[cursor];
+            const item = items[itemIndex];
+            if (item && item.type === 'item') {
+                onSelect(item);
+            }
+        }
+        else if (key.escape || (key.ctrl && input === 'c')) {
+            onCancel?.();
+        }
+    });
+    if (items.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { children: chalk.bold(title) }), _jsx(Text, { children: "No results." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: chalk.dim('Press Esc to exit.') }) })] }));
+    }
+    const selectedRowIndex = selectableIndices[cursor] ?? 0;
+    const totalRows = items.length;
+    const effectiveMaxRows = Math.max(3, maxRows);
+    const windowStart = Math.min(Math.max(0, selectedRowIndex - Math.floor(effectiveMaxRows / 2)), Math.max(0, totalRows - effectiveMaxRows));
+    const windowEnd = Math.min(totalRows, windowStart + effectiveMaxRows);
+    const windowed = items.slice(windowStart, windowEnd);
+    return (_jsxs(Box, { flexDirection: "column", children: [title && _jsx(Text, { children: chalk.bold(title) }), windowed.map((row, idx) => {
+                const absoluteIndex = windowStart + idx;
+                const selected = row.type === 'item' && absoluteIndex === selectedRowIndex;
+                if (row.type === 'group') {
+                    const colored = row.color ? chalk.hex(row.color)(`[${row.label}]`) : `[${row.label}]`;
+                    return (_jsx(Box, { marginTop: idx === 0 ? 0 : 1, children: _jsx(Text, { children: chalk.bold(colored) }) }, `group-${absoluteIndex}`));
+                }
+                return (_jsxs(Box, { children: [_jsxs(Text, { children: [selected ? chalk.cyan.bold('› ') : '  ', selected ? chalk.cyan.bold(row.label) : row.label] }), row.hint ? _jsx(Text, { children: chalk.dim(` ${row.hint}`) }) : null] }, `item-${absoluteIndex}`));
+            }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: chalk.dim('Use ↑/↓ or j/k. Enter to select. Esc to cancel.') }) })] }));
+}

package/dist/ui/table.js

@@ -0,0 +1,214 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+import { sha1 } from "object-hash";
+/* Table */
+export default class Table extends React.Component {
+    /* Config */
+    /**
+     * Merges provided configuration with defaults.
+     */
+    getConfig() {
+        return {
+            data: this.props.data,
+            columns: this.props.columns || this.getDataKeys(),
+            padding: this.props.padding || 1,
+            header: this.props.header || Header,
+            cell: this.props.cell || Cell,
+            skeleton: this.props.skeleton || Skeleton,
+        };
+    }
+    /**
+     * Gets all keyes used in data by traversing through the data.
+     */
+    getDataKeys() {
+        let keys = new Set();
+        // Collect all the keys.
+        for (const data of this.props.data) {
+            for (const key in data) {
+                keys.add(key);
+            }
+        }
+        return Array.from(keys);
+    }
+    /**
+     * Calculates the width of each column by finding
+     * the longest value in a cell of a particular column.
+     *
+     * Returns a list of column names and their widths.
+     */
+    getColumns() {
+        const { columns, padding } = this.getConfig();
+        const widths = columns.map((key) => {
+            const header = String(key).length;
+            /* Get the width of each cell in the column */
+            const data = this.props.data.map((data) => {
+                const value = data[key];
+                if (value == undefined || value == null)
+                    return 0;
+                return String(value).length;
+            });
+            const width = Math.max(...data, header) + padding * 2;
+            /* Construct a cell */
+            return {
+                column: key,
+                width: width,
+                key: String(key),
+            };
+        });
+        return widths;
+    }
+    /**
+     * Returns a (data) row representing the headings.
+     */
+    getHeadings() {
+        const { columns } = this.getConfig();
+        const headings = columns.reduce((acc, column) => ({ ...acc, [column]: column }), {});
+        return headings;
+    }
+    /* Rendering utilities */
+    // The top most line in the table.
+    header = row({
+        cell: this.getConfig().skeleton,
+        padding: this.getConfig().padding,
+        skeleton: {
+            component: this.getConfig().skeleton,
+            // chars
+            line: "─",
+            left: "┌",
+            right: "┐",
+            cross: "┬",
+        },
+    });
+    // The line with column names.
+    heading = row({
+        cell: this.getConfig().header,
+        padding: this.getConfig().padding,
+        skeleton: {
+            component: this.getConfig().skeleton,
+            // chars
+            line: " ",
+            left: "│",
+            right: "│",
+            cross: "│",
+        },
+    });
+    // The line that separates rows.
+    separator = row({
+        cell: this.getConfig().skeleton,
+        padding: this.getConfig().padding,
+        skeleton: {
+            component: this.getConfig().skeleton,
+            // chars
+            line: "─",
+            left: "├",
+            right: "┤",
+            cross: "┼",
+        },
+    });
+    // The row with the data.
+    data = row({
+        cell: this.getConfig().cell,
+        padding: this.getConfig().padding,
+        skeleton: {
+            component: this.getConfig().skeleton,
+            // chars
+            line: " ",
+            left: "│",
+            right: "│",
+            cross: "│",
+        },
+    });
+    // The bottom most line of the table.
+    footer = row({
+        cell: this.getConfig().skeleton,
+        padding: this.getConfig().padding,
+        skeleton: {
+            component: this.getConfig().skeleton,
+            // chars
+            line: "─",
+            left: "└",
+            right: "┘",
+            cross: "┴",
+        },
+    });
+    /* Render */
+    render() {
+        /* Data */
+        const columns = this.getColumns();
+        const headings = this.getHeadings();
+        /**
+         * Render the table line by line.
+         */
+        return (_jsxs(Box, { flexDirection: "column", children: [this.header({ key: "header", columns, data: {} }), this.heading({ key: "heading", columns, data: headings }), this.props.data.map((row, index) => {
+                    // Calculate the hash of the row based on its value and position
+                    const key = `row-${sha1(row)}-${index}`;
+                    // Construct a row.
+                    return (_jsxs(Box, { flexDirection: "column", children: [this.separator({ key: `separator-${key}`, columns, data: {} }), this.data({ key: `data-${key}`, columns, data: row })] }, key));
+                }), this.footer({ key: "footer", columns, data: {} })] }));
+    }
+}
+/**
+ * Constructs a Row element from the configuration.
+ */
+function row(config) {
+    /* This is a component builder. We return a function. */
+    const skeleton = config.skeleton;
+    /* Row */
+    return (props) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(skeleton.component, { children: skeleton.left }), ...intersperse((i) => {
+                const key = `${props.key}-hseparator-${i}`;
+                // The horizontal separator.
+                return (_jsx(skeleton.component, { children: skeleton.cross }, key));
+            }, 
+            // Values.
+            props.columns.map((column, colI) => {
+                // content
+                const value = props.data[column.column];
+                if (value == undefined || value == null) {
+                    const key = `${props.key}-empty-${column.key}`;
+                    return (_jsx(config.cell, { column: colI, children: skeleton.line.repeat(column.width) }, key));
+                }
+                else {
+                    const key = `${props.key}-cell-${column.key}`;
+                    // margins
+                    const ml = config.padding;
+                    const mr = column.width - String(value).length - config.padding;
+                    return (
+                    /* prettier-ignore */
+                    _jsx(config.cell, { column: colI, children: `${skeleton.line.repeat(ml)}${String(value)}${skeleton.line.repeat(mr)}` }, key));
+                }
+            })), _jsx(skeleton.component, { children: skeleton.right })] }));
+}
+/**
+ * Renders the header of a table.
+ */
+export function Header(props) {
+    return (_jsx(Text, { bold: true, color: "blue", children: props.children }));
+}
+/**
+ * Renders a cell in the table.
+ */
+export function Cell(props) {
+    return _jsx(Text, { children: props.children });
+}
+/**
+ * Redners the scaffold of the table.
+ */
+export function Skeleton(props) {
+    return _jsx(Text, { bold: true, children: props.children });
+}
+/* Utility functions */
+/**
+ * Intersperses a list of elements with another element.
+ */
+function intersperse(intersperser, elements) {
+    // Intersparse by reducing from left.
+    let interspersed = elements.reduce((acc, element, index) => {
+        // Only add element if it's the first one.
+        if (acc.length === 0)
+            return [element];
+        // Add the intersparser as well otherwise.
+        return [...acc, intersperser(index), element];
+    }, []);
+    return interspersed;
+}

package/dist/utils/format.js

@@ -0,0 +1,9 @@
+export function formatDate(iso) {
+    if (!iso)
+        return "unknown";
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return iso;
+    // Pretty print the date in local time
+    return date.toLocaleString();
+}

package/dist/utils/output.js

@@ -0,0 +1,14 @@
+function shellQuote(value) {
+    return JSON.stringify(value);
+}
+export function emitSelection(project, mode = {}) {
+    if (mode.printOnly || process.env.BET_EVAL !== '1') {
+        process.stdout.write(`${project.path}\n`);
+        return;
+    }
+    const lines = [`cd ${shellQuote(project.path)}`];
+    if (!mode.noEnter && project.user?.onEnter) {
+        lines.push(project.user.onEnter);
+    }
+    process.stdout.write(`__BET_EVAL__${lines.join('\n')}`);
+}

package/dist/utils/paths.js

@@ -0,0 +1,19 @@
+import os from 'node:os';
+import path from 'node:path';
+export function expandHome(inputPath) {
+    if (!inputPath)
+        return inputPath;
+    if (inputPath === '~')
+        return os.homedir();
+    if (inputPath.startsWith('~/')) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+export function normalizeAbsolute(inputPath) {
+    return path.resolve(expandHome(inputPath));
+}
+export function isSubpath(child, parent) {
+    const rel = path.relative(parent, child);
+    return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "bet-cli",
+  "description": "Explore and jump between local projects.",
+  "author": "Chris Mckenzie",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kenzic/bet-cli"
+  },
+  "homepage": "https://github.com/kenzic/bet-cli",
+  "keywords": [
+    "cli",
+    "project",
+    "management",
+    "navigation"
+  ],
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "bet": "dist/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@types/object-hash": "^3.0.6",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "fast-glob": "^3.3.2",
+    "fuse.js": "^7.0.0",
+    "ink": "^6.6.0",
+    "ink-markdown": "^1.0.4",
+    "ink-table": "^3.1.0",
+    "object-hash": "^3.0.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "@types/react": "^19.2.13",
+    "@vitest/coverage-v8": "^2.1.8",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
+  }
+}

package/src/commands/go.ts

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { readConfig } from '../lib/config.js';
+import { findBySlug, listProjects, projectLabel } from '../lib/projects.js';
+import { emitSelection } from '../utils/output.js';
+import { promptSelect } from '../ui/prompt.js';
+import { SelectEntry } from '../ui/select.js';
+
+export function registerGo(program: Command): void {
+  program
+    .command('go <slug>')
+    .description('Print a shell snippet to cd into a project')
+    .option('--print', 'Print selected path only')
+    .option('--no-enter', 'Do not run onEnter command')
+    .action(async (slug: string, options: { print?: boolean; enter?: boolean }) => {
+      const config = await readConfig();
+      const projects = listProjects(config);
+      const matches = findBySlug(projects, slug);
+
+      if (matches.length === 0) {
+        process.stderr.write(`No project found for slug "${slug}".\n`);
+        process.exitCode = 1;
+        return;
+      }
+
+      let project = matches[0];
+      if (matches.length > 1) {
+        if (!process.stdin.isTTY) {
+          process.stderr.write(`Slug "${slug}" is ambiguous. Matches:\n`);
+          for (const item of matches) {
+            process.stderr.write(`  ${projectLabel(item)} ${item.path}\n`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const items: SelectEntry<typeof matches[number]>[] = matches.map((item) => ({
+          label: projectLabel(item),
+          hint: item.path,
+          value: item,
+          type: 'item',
+        }));
+
+        const selected = await promptSelect(items, { title: `Select ${slug}` });
+        if (!selected) return;
+        project = selected.value;
+      }
+
+      emitSelection(project, { printOnly: options.print, noEnter: options.enter === false });
+    });
+}

package/src/commands/info.tsx

@@ -0,0 +1,168 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { readConfig } from "../lib/config.js";
+import { render, Box, Text } from "ink";
+import { findBySlug, listProjects, projectLabel } from "../lib/projects.js";
+import { getDirtyStatus, isInsideGitRepo } from "../lib/git.js";
+import { formatDate } from "../utils/format.js";
+import { promptSelect } from "../ui/prompt.js";
+import { SelectEntry } from "../ui/select.js";
+import { readReadmeContent } from "../lib/readme.js";
+import Table from "../ui/table.js";
+
+const data: { [key: string]: string }[] = [];
+
+export function registerInfo(program: Command): void {
+  program
+    .command("info <slug>")
+    .description("Show project details")
+    .option("--json", "Print JSON output")
+    .action(async (slug: string, options: { json?: boolean }) => {
+      const config = await readConfig();
+      const projects = listProjects(config);
+      const matches = findBySlug(projects, slug);
+
+      if (matches.length === 0) {
+        process.stderr.write(`No project found for slug "${slug}".\n`);
+        process.exitCode = 1;
+        return;
+      }
+
+      let project = matches[0];
+
+      if (matches.length > 1) {
+        if (!process.stdin.isTTY) {
+          process.stderr.write(`Slug "${slug}" is ambiguous. Matches:\n`);
+          for (const item of matches) {
+            process.stderr.write(`  ${projectLabel(item)} ${item.path}\n`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const items: SelectEntry<(typeof matches)[number]>[] = matches.map(
+          (item) => ({
+            label: projectLabel(item),
+            hint: item.path,
+            value: item,
+            type: "item",
+          }),
+        );
+
+        const selected = await promptSelect(items, { title: `Select ${slug}` });
+        if (!selected) return;
+        project = selected.value;
+      }
+
+      if (options.json) {
+        process.stdout.write(JSON.stringify(project, null, 2));
+        process.stdout.write("\n");
+        return;
+      }
+
+      const description =
+        project.user?.description ?? project.auto.description ?? "—";
+      // Compute git status live
+      const hasGit = await isInsideGitRepo(project.path);
+      const dirty = hasGit ? await getDirtyStatus(project.path) : undefined;
+
+      if (process.stdin.isTTY) {
+        const readme = await readReadmeContent(project.path);
+        const markdown = readme ?? description;
+
+        let Markdown: React.FC<{ children: string }> | null = null;
+        try {
+          const markdownModule = await import("ink-markdown");
+          Markdown = (markdownModule.default ??
+            markdownModule) as unknown as React.FC<{
+            children: string;
+          }>;
+        } catch {
+          Markdown = null;
+        }
+
+        const view = (
+          <Box flexDirection="column">
+            <Table data={data} />
+            <Text color="green" bold>
+              {project.slug}
+            </Text>
+            <Text dimColor>{project.path}</Text>
+            <Box marginTop={1} flexDirection="column">
+              <Text bold>{`Root: ${project.rootName}`}</Text>
+              <Text bold>{`Root path: ${project.root}`}</Text>
+              <Text bold>{`Git: ${hasGit ? "yes" : "no"}`}</Text>
+              <Text bold>{`README: ${project.hasReadme ? "yes" : "no"}`}</Text>
+              <Text
+                bold
+              >{`Started: ${formatDate(project.auto.startedAt)}`}</Text>
+              <Text
+                bold
+              >{`Last modified: ${formatDate(project.auto.lastModifiedAt)}`}</Text>
+              <Text
+                bold
+              >{`Last indexed: ${formatDate(project.auto.lastIndexedAt)}`}</Text>
+              <Text
+                bold
+              >{`Dirty: ${dirty === undefined ? "unknown" : dirty ? "yes" : "no"}`}</Text>
+              {project.user?.tags?.length ? (
+                <Text>{`Tags: ${project.user.tags.join(", ")}`}</Text>
+              ) : null}
+              {project.user?.onEnter ? (
+                <Text>{`On enter: ${project.user.onEnter}`}</Text>
+              ) : null}
+            </Box>
+            <Box marginTop={1} flexDirection="column">
+              <Text>{chalk.bold("Description")}</Text>
+              {Markdown ? (
+                <Markdown>{markdown}</Markdown>
+              ) : (
+                <Text>{markdown}</Text>
+              )}
+            </Box>
+          </Box>
+        );
+
+        const { unmount } = render(view, { stdout: process.stdout });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        unmount();
+        return;
+      }
+
+      process.stdout.write(`${chalk.bold(project.slug)}\n`);
+      process.stdout.write(`${chalk.dim(project.path)}\n\n`);
+
+      process.stdout.write(`${chalk.bold("Root:")} ${project.rootName}\n`);
+      process.stdout.write(`${chalk.bold("Root path:")} ${project.root}\n`);
+      process.stdout.write(`${chalk.bold("Git:")} ${hasGit ? "yes" : "no"}\n`);
+      process.stdout.write(
+        `${chalk.bold("README:")} ${project.hasReadme ? "yes" : "no"}\n\n`,
+      );
+
+      process.stdout.write(`${chalk.bold("Description:")} ${description}\n`);
+      process.stdout.write(
+        `${chalk.bold("Started:")} ${formatDate(project.auto.startedAt)}\n`,
+      );
+      process.stdout.write(
+        `${chalk.bold("Last modified:")} ${formatDate(project.auto.lastModifiedAt)}\n`,
+      );
+      process.stdout.write(
+        `${chalk.bold("Last indexed:")} ${formatDate(project.auto.lastIndexedAt)}\n`,
+      );
+      process.stdout.write(
+        `${chalk.bold("Dirty:")} ${dirty === undefined ? "unknown" : dirty ? "yes" : "no"}\n`,
+      );
+
+      if (project.user?.tags?.length) {
+        process.stdout.write(
+          `${chalk.bold("Tags:")} ${project.user.tags.join(", ")}\n`,
+        );
+      }
+
+      if (project.user?.onEnter) {
+        process.stdout.write(
+          `${chalk.bold("On enter:")} ${project.user.onEnter}\n`,
+        );
+      }
+    });
+}