bet-cli 0.1.0

package/src/lib/cron.ts

@@ -0,0 +1,96 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { getConfigPath } from "./config.js";
+
+const CRON_MARKER = "# bet:update hourly";
+const WRAPPER_SCRIPT_NAME = "bet-update-cron.sh";
+const LOG_FILE_NAME = "cron-update.log";
+
+export type InstallHourlyUpdateCronOptions = {
+  /** Absolute path to the Node binary (e.g. process.execPath). */
+  nodePath: string;
+  /** Absolute path to the bet CLI entry script (e.g. dist/index.js). */
+  entryScriptPath: string;
+};
+
+/**
+ * Writes a wrapper script and installs/updates a per-user crontab entry
+ * so that `bet update` runs every hour. Idempotent: re-running replaces
+ * the existing bet cron block.
+ */
+export async function installHourlyUpdateCron(
+  options: InstallHourlyUpdateCronOptions,
+): Promise<void> {
+  const { nodePath, entryScriptPath } = options;
+  const configDir = path.dirname(getConfigPath());
+  await fs.mkdir(configDir, { recursive: true });
+
+  const wrapperPath = path.join(configDir, WRAPPER_SCRIPT_NAME);
+  const logPath = path.join(configDir, LOG_FILE_NAME);
+
+  const scriptBody = [
+    "#!/bin/sh",
+    `"${nodePath}" "${entryScriptPath}" update >> "${logPath}" 2>&1`,
+  ].join("\n");
+
+  await fs.writeFile(wrapperPath, scriptBody + "\n", "utf8");
+  await fs.chmod(wrapperPath, 0o755);
+
+  const scheduleLine = `0 * * * * ${wrapperPath}`;
+  const betBlock = [CRON_MARKER, scheduleLine].join("\n");
+
+  const crontabL = spawnSync("crontab", ["-l"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  let existingCrontab = "";
+  if (crontabL.status === 0 && crontabL.stdout) {
+    existingCrontab = crontabL.stdout;
+  }
+  if (crontabL.status !== 0 && crontabL.stderr && !crontabL.stderr.includes("no crontab")) {
+    throw new Error(`crontab -l failed: ${crontabL.stderr}`);
+  }
+
+  const lines = existingCrontab.split("\n");
+  const out: string[] = [];
+  let skipNext = false;
+  let betBlockReplaced = false;
+
+  for (const line of lines) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    if (line === CRON_MARKER) {
+      if (!betBlockReplaced) {
+        out.push(betBlock);
+        betBlockReplaced = true;
+      }
+      skipNext = true;
+      continue;
+    }
+    out.push(line);
+  }
+
+  if (!betBlockReplaced) {
+    if (out.length > 0 && !out[out.length - 1].endsWith("\n") && out[out.length - 1] !== "") {
+      out.push("");
+    }
+    out.push(betBlock);
+  }
+
+  const newCrontab = out.join("\n").replace(/\n*$/, "") + "\n";
+
+  const crontabWrite = spawnSync("crontab", ["-"], {
+    encoding: "utf8",
+    input: newCrontab,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  if (crontabWrite.status !== 0) {
+    const err = crontabWrite.stderr || crontabWrite.stdout || "unknown";
+    throw new Error(`crontab install failed: ${err}`);
+  }
+}

package/src/lib/git.ts

@@ -0,0 +1,31 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+async function runGit(cwd: string, args: string[]): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync('git', ['-C', cwd, ...args], {
+      encoding: 'utf8',
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function getFirstCommitDate(cwd: string): Promise<string | undefined> {
+  const output = await runGit(cwd, ['log', '--reverse', '--format=%cI', '-n', '1']);
+  return output || undefined;
+}
+
+export async function getDirtyStatus(cwd: string): Promise<boolean | undefined> {
+  const output = await runGit(cwd, ['status', '--porcelain']);
+  if (output === null) return undefined;
+  return output.length > 0;
+}
+
+export async function isInsideGitRepo(cwd: string): Promise<boolean> {
+  const output = await runGit(cwd, ['rev-parse', '--is-inside-work-tree']);
+  return output === 'true';
+}

package/src/lib/ignore.ts

@@ -0,0 +1,11 @@
+export const DEFAULT_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/target/**",
+  "**/vendor/**",
+  "**/.venv/**",
+  "**/venv/**",
+];

package/src/lib/metadata.ts

@@ -0,0 +1,41 @@
+import fg from 'fast-glob';
+import { DEFAULT_IGNORES } from './ignore.js';
+import { ProjectAutoMetadata } from './types.js';
+import { getDirtyStatus, getFirstCommitDate } from './git.js';
+import { readReadmeDescription } from './readme.js';
+
+export async function computeMetadata(projectPath: string, hasGit: boolean): Promise<ProjectAutoMetadata> {
+  const nowIso = new Date().toISOString();
+
+  const entries = await fg('**/*', {
+    cwd: projectPath,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: DEFAULT_IGNORES,
+    stats: true,
+  });
+
+  let oldest: number | undefined;
+  let newest: number | undefined;
+
+  for (const entry of entries) {
+    const stats = entry.stats;
+    if (!stats) continue;
+    const mtime = stats.mtimeMs;
+    if (oldest === undefined || mtime < oldest) oldest = mtime;
+    if (newest === undefined || mtime > newest) newest = mtime;
+  }
+
+  const description = await readReadmeDescription(projectPath);
+  const startedAt = hasGit ? await getFirstCommitDate(projectPath) : undefined;
+  const dirty = hasGit ? await getDirtyStatus(projectPath) : undefined;
+
+  return {
+    description,
+    startedAt: startedAt ?? (oldest ? new Date(oldest).toISOString() : undefined),
+    lastModifiedAt: newest ? new Date(newest).toISOString() : undefined,
+    lastIndexedAt: nowIso,
+    dirty,
+  };
+}

package/src/lib/projects.ts

@@ -0,0 +1,18 @@
+import { Config, Project } from './types.js';
+
+export function listProjects(config: Config): Project[] {
+  const projects = Object.values(config.projects);
+  return projects.sort((a, b) => {
+    if (a.rootName !== b.rootName) return a.rootName.localeCompare(b.rootName);
+    return a.slug.localeCompare(b.slug);
+  });
+}
+
+export function projectLabel(project: Project): string {
+  return `${project.rootName}/${project.slug}`;
+}
+
+export function findBySlug(projects: Project[], slug: string): Project[] {
+  const normalized = slug.trim().toLowerCase();
+  return projects.filter((project) => project.slug.toLowerCase() === normalized);
+}

package/src/lib/readme.ts

@@ -0,0 +1,83 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const README_NAMES = ["README.md", "readme.md", "Readme.md", "README.MD"];
+
+export async function readReadmePath(
+  projectPath: string,
+): Promise<string | undefined> {
+  for (const name of README_NAMES) {
+    const candidate = path.join(projectPath, name);
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+      // ignore
+    }
+  }
+  return undefined;
+}
+
+export async function readReadmeContent(
+  projectPath: string,
+): Promise<string | undefined> {
+  const readmePath = await readReadmePath(projectPath);
+  if (!readmePath) return undefined;
+
+  let content = await fs.readFile(readmePath, "utf8");
+  // remove html tags
+  content = content.replace(/<[^>]*>?/g, "");
+
+  // only graph the first 300 characters, and add ... if there are more
+  const truncated = content.slice(0, 500);
+  if (content.length > 500) {
+    return `${truncated}...`;
+  }
+  return truncated;
+}
+
+export async function readReadmeDescription(
+  projectPath: string,
+): Promise<string | undefined> {
+  const readmePath = await readReadmePath(projectPath);
+  if (!readmePath) return undefined;
+
+  const raw = await fs.readFile(readmePath, "utf8");
+  const lines = raw.split(/\r?\n/);
+
+  let title: string | undefined;
+  let paragraph: string[] = [];
+  let inCodeBlock = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+
+    if (inCodeBlock) continue;
+
+    if (!title && trimmed.startsWith("#")) {
+      title = trimmed.replace(/^#+\s*/, "").trim();
+      continue;
+    }
+
+    if (title) {
+      if (trimmed.length === 0) {
+        if (paragraph.length > 0) break;
+        continue;
+      }
+      if (trimmed.startsWith("#")) {
+        if (paragraph.length > 0) break;
+        continue;
+      }
+      paragraph.push(trimmed);
+    }
+  }
+
+  const description = paragraph.join(" ").trim();
+  if (description) return description;
+  return title || undefined;
+}

package/src/lib/scan.ts

@@ -0,0 +1,116 @@
+import path from "node:path";
+import fg from "fast-glob";
+import { ProjectCandidate } from "./types.js";
+import { DEFAULT_IGNORES } from "./ignore.js";
+import { isSubpath } from "../utils/paths.js";
+import { isInsideGitRepo } from "./git.js";
+
+const README_PATTERNS = [
+  "**/README.md",
+  "**/readme.md",
+  "**/Readme.md",
+  "**/README.MD",
+];
+
+function resolveProjectRoot(matchPath: string): string {
+  const container = path.dirname(matchPath);
+  // if (
+  //   path.basename(container) === "src" ||
+  //   path.basename(container) === "app"
+  // ) {
+  //   return path.dirname(container);
+  // }
+  return container;
+}
+
+function addCandidate(
+  map: Map<string, ProjectCandidate>,
+  projectPath: string,
+  root: string,
+  flags: Partial<Pick<ProjectCandidate, "hasGit" | "hasReadme">>,
+): void {
+  const existing = map.get(projectPath);
+  const base: ProjectCandidate = existing ?? {
+    path: projectPath,
+    root,
+    hasGit: false,
+    hasReadme: false,
+  };
+
+  const next: ProjectCandidate = {
+    ...base,
+    ...flags,
+  };
+
+  if (existing && root.length > existing.root.length) {
+    next.root = root;
+  }
+
+  map.set(projectPath, next);
+}
+
+export async function scanRoots(roots: string[]): Promise<ProjectCandidate[]> {
+  const candidates = new Map<string, ProjectCandidate>();
+
+  for (const root of roots) {
+    // Exclude .git/** from ignores when scanning for .git directories
+    const gitIgnores = DEFAULT_IGNORES.filter(
+      (pattern) => pattern !== "**/.git/**",
+    );
+    const gitMatches = await fg("**/.git", {
+      cwd: root,
+      dot: true,
+      onlyDirectories: false,
+      onlyFiles: false,
+      followSymbolicLinks: false,
+      ignore: gitIgnores,
+    });
+
+    for (const match of gitMatches) {
+      const absMatch = path.join(root, match);
+      const projectRoot = resolveProjectRoot(absMatch);
+      if (!projectRoot.startsWith(root)) continue;
+      addCandidate(candidates, projectRoot, root, { hasGit: true });
+    }
+
+    const readmeMatches = await fg(README_PATTERNS, {
+      cwd: root,
+      dot: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      ignore: DEFAULT_IGNORES,
+    });
+
+    for (const match of readmeMatches) {
+      const absMatch = path.join(root, match);
+      const projectRoot = resolveProjectRoot(absMatch);
+      if (!projectRoot.startsWith(root)) continue;
+      addCandidate(candidates, projectRoot, root, { hasReadme: true });
+    }
+  }
+
+  const list = Array.from(candidates.values());
+  list.sort((a, b) => a.path.length - b.path.length);
+
+  const filtered: ProjectCandidate[] = [];
+  for (const candidate of list) {
+    const nested = filtered.some((kept) =>
+      isSubpath(candidate.path, kept.path),
+    );
+    if (!nested) {
+      filtered.push(candidate);
+    }
+  }
+
+  // Check git status for all candidates (including those inside parent repos)
+  for (const candidate of filtered) {
+    if (!candidate.hasGit) {
+      const hasGit = await isInsideGitRepo(candidate.path);
+      if (hasGit) {
+        candidate.hasGit = true;
+      }
+    }
+  }
+
+  return filtered;
+}

package/src/lib/search.ts

@@ -0,0 +1,22 @@
+import Fuse from 'fuse.js';
+import { Project } from './types.js';
+
+export function searchProjects(projects: Project[], query: string): Project[] {
+  if (!query.trim()) return projects;
+  const fuse = new Fuse(projects, {
+    keys: [
+      'slug',
+      'name',
+      'path',
+      'rootName',
+      'root',
+      'user.tags',
+      'user.description',
+      'auto.description'
+    ],
+    includeScore: true,
+    threshold: 0.4,
+  });
+
+  return fuse.search(query).map((result) => result.item);
+}

package/src/lib/types.ts

@@ -0,0 +1,53 @@
+export type ProjectAutoMetadata = {
+  description?: string;
+  startedAt?: string;
+  lastModifiedAt?: string;
+  lastIndexedAt: string;
+  dirty?: boolean;
+};
+
+export type ProjectUserMetadata = {
+  description?: string;
+  onEnter?: string;
+  tags?: string[];
+};
+
+export type Project = {
+  id: string;
+  slug: string;
+  name: string;
+  path: string;
+  root: string;
+  rootName: string;
+  hasGit: boolean;
+  hasReadme: boolean;
+  auto: ProjectAutoMetadata;
+  user?: ProjectUserMetadata;
+};
+
+export type RootConfig = {
+  path: string;
+  name: string;
+};
+
+export type AppConfig = {
+  version: number;
+  roots: RootConfig[];
+};
+
+export type ProjectsConfig = {
+  projects: Record<string, Project>;
+};
+
+export type Config = {
+  version: number;
+  roots: RootConfig[];
+  projects: Record<string, Project>;
+};
+
+export type ProjectCandidate = {
+  path: string;
+  root: string;
+  hasGit: boolean;
+  hasReadme: boolean;
+};

package/src/ui/prompt.tsx

@@ -0,0 +1,63 @@
+import React from 'react';
+import { render } from 'ink';
+import { SelectEntry, SelectList, SelectRow } from './select.js';
+import { SearchSelect } from './search.js';
+
+export async function promptSelect<T>(
+  items: SelectRow<T>[],
+  options: { title?: string; maxRows?: number } = {}
+): Promise<SelectEntry<T> | undefined> {
+  return new Promise((resolve) => {
+    const { unmount } = render(
+      <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<T>(
+  items: SelectEntry<T>[],
+  options: {
+    title?: string;
+    initialQuery?: string;
+    maxRows?: number;
+    filter: (items: SelectEntry<T>[], query: string) => SelectEntry<T>[];
+  }
+): Promise<SelectEntry<T> | undefined> {
+  return new Promise((resolve) => {
+    const { unmount } = render(
+      <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/src/ui/search.tsx

@@ -0,0 +1,111 @@
+import React, { useMemo, useState } from 'react';
+import chalk from 'chalk';
+import { Box, Text, useInput } from 'ink';
+import { SelectEntry } from './select.js';
+
+const DEFAULT_MAX_ROWS = 18;
+
+export type SearchSelectProps<T> = {
+  title?: string;
+  allItems: SelectEntry<T>[];
+  filter: (items: SelectEntry<T>[], query: string) => SelectEntry<T>[];
+  onSelect: (item: SelectEntry<T>) => void;
+  onCancel?: () => void;
+  maxRows?: number;
+  initialQuery?: string;
+  showCount?: boolean;
+};
+
+export function SearchSelect<T>({
+  title,
+  allItems,
+  filter,
+  onSelect,
+  onCancel,
+  maxRows = DEFAULT_MAX_ROWS,
+  initialQuery = '',
+  showCount = true,
+}: SearchSelectProps<T>): React.ReactElement {
+  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 (
+      <Box flexDirection="column">
+        {title && <Text>{chalk.bold(title)}</Text>}
+        <Text>{`Search: ${query}`}</Text>
+        <Text>No results.</Text>
+      </Box>
+    );
+  }
+
+  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 (
+    <Box flexDirection="column">
+      {title && <Text>{chalk.bold(title)}</Text>}
+      <Text>{`Search: ${query}`}</Text>
+      {showCount && <Text>{chalk.dim(`${items.length} result(s)`)}</Text>}
+      {windowed.map((row, idx) => {
+        const absoluteIndex = windowStart + idx;
+        const selected = absoluteIndex === selectedRowIndex;
+        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('Type to filter. Use ↑/↓ or j/k. Enter to select. Esc to cancel.')}</Text>
+      </Box>
+    </Box>
+  );
+}