bet-cli 0.1.0

package/src/ui/select.tsx

@@ -0,0 +1,119 @@
+import React, { useMemo, useState } from 'react';
+import chalk from 'chalk';
+import { Box, Text, useInput } from 'ink';
+
+export type SelectGroup = {
+  type: 'group';
+  label: string;
+  color?: string;
+};
+
+export type SelectEntry<T> = {
+  type: 'item';
+  label: string;
+  value: T;
+  hint?: string;
+};
+
+export type SelectRow<T> = SelectGroup | SelectEntry<T>;
+
+type SelectListProps<T> = {
+  title?: string;
+  items: SelectRow<T>[];
+  onSelect: (item: SelectEntry<T>) => void;
+  onCancel?: () => void;
+  maxRows?: number;
+};
+
+const DEFAULT_MAX_ROWS = 18;
+
+export function SelectList<T>({
+  title,
+  items,
+  onSelect,
+  onCancel,
+  maxRows = DEFAULT_MAX_ROWS,
+}: SelectListProps<T>): React.ReactElement {
+  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 (
+      <Box flexDirection="column">
+        {title && <Text>{chalk.bold(title)}</Text>}
+        <Text>No results.</Text>
+        <Box marginTop={1}>
+        <Text>{chalk.dim('Press Esc to exit.')}</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  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 (
+    <Box flexDirection="column">
+      {title && <Text>{chalk.bold(title)}</Text>}
+      {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 (
+            <Box key={`group-${absoluteIndex}`} marginTop={idx === 0 ? 0 : 1}>
+              <Text>{chalk.bold(colored)}</Text>
+            </Box>
+          );
+        }
+
+        return (
+          <Box key={`item-${absoluteIndex}`}>
+            <Text>
+              {selected ? chalk.cyan.bold('› ') : '  '}
+              {selected ? chalk.cyan.bold(row.label) : row.label}
+            </Text>
+            {row.hint ? <Text>{chalk.dim(` ${row.hint}`)}</Text> : null}
+          </Box>
+        );
+      })}
+      <Box marginTop={1}>
+        <Text>{chalk.dim('Use ↑/↓ or j/k. Enter to select. Esc to cancel.')}</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/ui/table.tsx

@@ -0,0 +1,380 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { sha1 } from "object-hash";
+
+/* Table */
+
+type Scalar = string | number | boolean | null | undefined;
+
+type ScalarDict = {
+  [key: string]: Scalar;
+};
+
+export type CellProps = React.PropsWithChildren<{ column: number }>;
+
+export type TableProps<T extends ScalarDict> = {
+  /**
+   * List of values (rows).
+   */
+  data: T[];
+  /**
+   * Columns that we should display in the table.
+   */
+  columns: (keyof T)[];
+  /**
+   * Cell padding.
+   */
+  padding: number;
+  /**
+   * Header component.
+   */
+  header: (props: React.PropsWithChildren<{}>) => React.ReactElement;
+  /**
+   * Component used to render a cell in the table.
+   */
+  cell: (props: CellProps) => React.ReactElement;
+  /**
+   * Component used to render the skeleton of the table.
+   */
+  skeleton: (props: React.PropsWithChildren<{}>) => React.ReactElement;
+};
+
+/* Table */
+
+export default class Table<T extends ScalarDict> extends React.Component<
+  Pick<TableProps<T>, "data"> & Partial<TableProps<T>>
+> {
+  /* Config */
+
+  /**
+   * Merges provided configuration with defaults.
+   */
+  getConfig(): TableProps<T> {
+    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(): (keyof T)[] {
+    let keys = new Set<keyof T>();
+
+    // 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(): Column<T>[] {
+    const { columns, padding } = this.getConfig();
+
+    const widths: Column<T>[] = 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(): Partial<T> {
+    const { columns } = this.getConfig();
+
+    const headings: Partial<T> = columns.reduce(
+      (acc, column) => ({ ...acc, [column]: column }),
+      {},
+    );
+
+    return headings;
+  }
+
+  /* Rendering utilities */
+
+  // The top most line in the table.
+  header = row<T>({
+    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<T>({
+    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<T>({
+    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<T>({
+    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<T>({
+    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 (
+      <Box flexDirection="column">
+        {/* Header */}
+        {this.header({ key: "header", columns, data: {} })}
+        {this.heading({ key: "heading", columns, data: headings })}
+        {/* Data */}
+        {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 (
+            <Box flexDirection="column" key={key}>
+              {this.separator({ key: `separator-${key}`, columns, data: {} })}
+              {this.data({ key: `data-${key}`, columns, data: row })}
+            </Box>
+          );
+        })}
+        {/* Footer */}
+        {this.footer({ key: "footer", columns, data: {} })}
+      </Box>
+    );
+  }
+}
+
+/* Helper components */
+
+type RowConfig = {
+  /**
+   * Component used to render cells.
+   */
+  cell: (props: CellProps) => React.ReactElement;
+  /**
+   * Tells the padding of each cell.
+   */
+  padding: number;
+  /**
+   * Component used to render skeleton in the row.
+   */
+  skeleton: {
+    component: (props: React.PropsWithChildren<{}>) => React.ReactElement;
+    /**
+     * Characters used in skeleton.
+     *    |             |
+     * (left)-(line)-(cross)-(line)-(right)
+     *    |             |
+     */
+    left: string;
+    right: string;
+    cross: string;
+    line: string;
+  };
+};
+
+type RowProps<T extends ScalarDict> = {
+  key: string;
+  data: Partial<T>;
+  columns: Column<T>[];
+};
+
+type Column<T> = {
+  key: string;
+  column: keyof T;
+  width: number;
+};
+
+/**
+ * Constructs a Row element from the configuration.
+ */
+function row<T extends ScalarDict>(
+  config: RowConfig,
+): (props: RowProps<T>) => React.ReactElement {
+  /* This is a component builder. We return a function. */
+
+  const skeleton = config.skeleton;
+
+  /* Row */
+  return (props) => (
+    <Box flexDirection="row">
+      {/* Left */}
+      <skeleton.component>{skeleton.left}</skeleton.component>
+      {/* Data */}
+      {...intersperse(
+        (i) => {
+          const key = `${props.key}-hseparator-${i}`;
+
+          // The horizontal separator.
+          return (
+            <skeleton.component key={key}>{skeleton.cross}</skeleton.component>
+          );
+        },
+
+        // 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 (
+              <config.cell key={key} column={colI}>
+                {skeleton.line.repeat(column.width)}
+              </config.cell>
+            );
+          } 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 */
+              <config.cell key={key} column={colI}>
+                {`${skeleton.line.repeat(ml)}${String(value)}${skeleton.line.repeat(mr)}`}
+              </config.cell>
+            );
+          }
+        }),
+      )}
+      {/* Right */}
+      <skeleton.component>{skeleton.right}</skeleton.component>
+    </Box>
+  );
+}
+
+/**
+ * Renders the header of a table.
+ */
+export function Header(props: React.PropsWithChildren<{}>) {
+  return (
+    <Text bold color="blue">
+      {props.children}
+    </Text>
+  );
+}
+
+/**
+ * Renders a cell in the table.
+ */
+export function Cell(props: CellProps) {
+  return <Text>{props.children}</Text>;
+}
+
+/**
+ * Redners the scaffold of the table.
+ */
+export function Skeleton(props: React.PropsWithChildren<{}>) {
+  return <Text bold>{props.children}</Text>;
+}
+
+/* Utility functions */
+
+/**
+ * Intersperses a list of elements with another element.
+ */
+function intersperse<T, I>(
+  intersperser: (index: number) => I,
+  elements: T[],
+): (T | I)[] {
+  // Intersparse by reducing from left.
+  let interspersed: (T | I)[] = 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];
+    },
+    [] as (T | I)[],
+  );
+
+  return interspersed;
+}

package/src/utils/format.ts

@@ -0,0 +1,8 @@
+export function formatDate(iso?: string): string {
+  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/src/utils/output.ts

@@ -0,0 +1,24 @@
+import { Project } from '../lib/types.js';
+
+export type OutputMode = {
+  printOnly?: boolean;
+  noEnter?: boolean;
+};
+
+function shellQuote(value: string): string {
+  return JSON.stringify(value);
+}
+
+export function emitSelection(project: Project, mode: OutputMode = {}): void {
+  if (mode.printOnly || process.env.BET_EVAL !== '1') {
+    process.stdout.write(`${project.path}\n`);
+    return;
+  }
+
+  const lines: string[] = [`cd ${shellQuote(project.path)}`];
+  if (!mode.noEnter && project.user?.onEnter) {
+    lines.push(project.user.onEnter);
+  }
+
+  process.stdout.write(`__BET_EVAL__${lines.join('\n')}`);
+}

package/src/utils/paths.ts

@@ -0,0 +1,20 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export function expandHome(inputPath: string): string {
+  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: string): string {
+  return path.resolve(expandHome(inputPath));
+}
+
+export function isSubpath(child: string, parent: string): boolean {
+  const rel = path.relative(parent, child);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}

package/tests/config.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { readConfig, resolveRoots, getConfigPath, getProjectsPath } from "../src/lib/config.js";
+import type { RootConfig } from "../src/lib/types.js";
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+  },
+}));
+
+describe("config", () => {
+  beforeEach(() => {
+    vi.mocked(fs.readFile).mockReset();
+  });
+
+  describe("readConfig", () => {
+    it("migrates legacy string[] roots to RootConfig[]", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(
+            JSON.stringify({ version: 1, roots: ["/tmp/foo", "~/bar"] }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(JSON.stringify({ projects: {} }));
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      expect(config.roots).toHaveLength(2);
+      expect(config.roots[0]).toEqual({
+        path: path.resolve("/tmp/foo"),
+        name: "foo",
+      });
+      expect(config.roots[1].path).toBe(
+        path.resolve(process.env.HOME || "", "bar"),
+      );
+      expect(config.roots[1].name).toBe("bar");
+    });
+
+    it("normalizes rootName on legacy projects that have group but no rootName", async () => {
+      const configPath = getConfigPath();
+      const projectsPath = getProjectsPath();
+      const resolvedRoot = path.resolve("/code");
+      vi.mocked(fs.readFile).mockImplementation((p: string) => {
+        if (p === configPath) {
+          return Promise.resolve(
+            JSON.stringify({
+              version: 1,
+              roots: [{ path: resolvedRoot, name: "my-code" }],
+            }),
+          );
+        }
+        if (p === projectsPath) {
+          return Promise.resolve(
+            JSON.stringify({
+              projects: {
+                "/code/app": {
+                  id: "/code/app",
+                  slug: "app",
+                  name: "app",
+                  path: "/code/app",
+                  root: resolvedRoot,
+                  group: "legacy-group",
+                  hasGit: true,
+                  hasReadme: true,
+                  auto: { lastIndexedAt: "2020-01-01T00:00:00.000Z" },
+                },
+              },
+            }),
+          );
+        }
+        return Promise.reject(new Error("ENOENT"));
+      });
+
+      const config = await readConfig();
+
+      const project = config.projects["/code/app"];
+      expect(project).toBeDefined();
+      expect(project.rootName).toBe("my-code");
+      expect((project as { group?: string }).group).toBeUndefined();
+    });
+  });
+
+  describe("resolveRoots", () => {
+    it("deduplicates by path and normalizes RootConfig", () => {
+      const input: RootConfig[] = [
+        { path: "/a/b", name: "b" },
+        { path: "/a/b", name: "other" },
+        { path: "/c", name: "c" },
+      ];
+      const result = resolveRoots(input);
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({ path: path.resolve("/a/b"), name: "b" });
+      expect(result[1]).toEqual({ path: path.resolve("/c"), name: "c" });
+    });
+  });
+});