bet-cli 0.1.0

package/src/commands/list.ts

@@ -0,0 +1,117 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { readConfig } from '../lib/config.js';
+import path from 'node:path';
+import { listProjects } from '../lib/projects.js';
+import type { Project, RootConfig } from '../lib/types.js';
+import { emitSelection } from '../utils/output.js';
+import { promptSelect } from '../ui/prompt.js';
+import { SelectRow } from '../ui/select.js';
+
+const MAX_ROWS = 18;
+const GROUP_COLORS = ['#22d3ee', '#34d399', '#facc15', '#c084fc', '#60a5fa', '#f87171'];
+
+function groupColor(index: number): string {
+  return GROUP_COLORS[index % GROUP_COLORS.length];
+}
+
+function relativePath(projectPath: string, root: string): string {
+  const rel = path.relative(root, projectPath);
+  return rel || path.basename(projectPath);
+}
+
+function formatLabel(slug: string, rootName: string, relPath: string): string {
+  return `${slug} [${rootName}] ${relPath}`;
+}
+
+function orderedGroupsByConfigRoots(
+  projects: Project[],
+  roots: RootConfig[],
+): { rootName: string; items: Project[] }[] {
+  const groupsByRoot = new Map<string, { rootName: string; items: Project[] }>();
+  for (const project of projects) {
+    const key = project.root;
+    if (!groupsByRoot.has(key)) {
+      groupsByRoot.set(key, { rootName: project.rootName, items: [] });
+    }
+    groupsByRoot.get(key)!.items.push(project);
+  }
+
+  const ordered: { rootName: string; items: Project[] }[] = [];
+  const seen = new Set<string>();
+
+  for (const rootConfig of roots) {
+    const group = groupsByRoot.get(rootConfig.path);
+    if (group) {
+      seen.add(rootConfig.path);
+      ordered.push({ rootName: rootConfig.name, items: group.items });
+    }
+  }
+
+  const remaining = [...groupsByRoot.entries()]
+    .filter(([rootPath]) => !seen.has(rootPath))
+    .sort((a, b) => a[1].rootName.localeCompare(b[1].rootName));
+  for (const [, group] of remaining) {
+    ordered.push(group);
+  }
+
+  return ordered;
+}
+
+export function registerList(program: Command): void {
+  program
+    .command('list')
+    .description('List projects')
+    .option('--plain', 'Print a non-interactive list')
+    .option('--json', 'Print JSON output')
+    .option('--print', 'Print selected path only')
+    .action(async (options: { plain?: boolean; json?: boolean; print?: boolean }) => {
+      const config = await readConfig();
+      const projects = listProjects(config);
+
+      if (options.json) {
+        process.stdout.write(JSON.stringify(projects, null, 2));
+        process.stdout.write('\n');
+        return;
+      }
+
+      if (!process.stdin.isTTY || options.plain) {
+        if (projects.length === 0) {
+          process.stdout.write('No projects indexed. Run bet update.\n');
+          return;
+        }
+        const orderedGroups = orderedGroupsByConfigRoots(projects, config.roots);
+        let groupIndex = 0;
+        for (const { rootName, items } of orderedGroups) {
+          const color = groupColor(groupIndex++);
+          const label = chalk.hex(color).bold(`[${rootName}]`);
+          process.stdout.write(`${label}\n`);
+          for (const project of items) {
+            const rel = relativePath(project.path, project.root);
+            process.stdout.write(`  ${chalk.reset(formatLabel(project.slug, project.rootName, rel))}\n`);
+          }
+        }
+        return;
+      }
+
+      const orderedGroups = orderedGroupsByConfigRoots(projects, config.roots);
+      const rows: SelectRow<Project>[] = [];
+      let groupIndex = 0;
+      for (const { rootName, items } of orderedGroups) {
+        rows.push({ type: 'group', label: rootName, color: groupColor(groupIndex++) });
+        for (const project of items) {
+          const rel = relativePath(project.path, project.root);
+          rows.push({
+            type: 'item',
+            label: formatLabel(project.slug, project.rootName, rel),
+            value: project,
+          });
+        }
+      }
+
+      const selected = await promptSelect(rows, { title: 'Projects', maxRows: MAX_ROWS });
+      if (!selected) return;
+
+      emitSelection(selected.value, { printOnly: options.print });
+    });
+}

package/src/commands/path.ts

@@ -0,0 +1,47 @@
+import { Command } from 'commander';
+import { readConfig } from '../lib/config.js';
+import { findBySlug, listProjects, projectLabel } from '../lib/projects.js';
+import { promptSelect } from '../ui/prompt.js';
+import { SelectEntry } from '../ui/select.js';
+
+export function registerPath(program: Command): void {
+  program
+    .command('path <slug>')
+    .description('Print the absolute path of a project by name')
+    .action(async (slug: string) => {
+      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;
+      }
+
+      process.stdout.write(`${project.path}\n`);
+    });
+}

package/src/commands/search.ts

@@ -0,0 +1,79 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { readConfig } from '../lib/config.js';
+import path from 'node:path';
+import { listProjects } from '../lib/projects.js';
+import { searchProjects } from '../lib/search.js';
+import { emitSelection } from '../utils/output.js';
+import { promptSearch } from '../ui/prompt.js';
+import { SelectEntry } from '../ui/select.js';
+
+const MAX_ROWS = 18;
+
+function relativePath(projectPath: string, root: string): string {
+  const rel = path.relative(root, projectPath);
+  return rel || path.basename(projectPath);
+}
+
+function formatLabel(slug: string, rootName: string, relPath: string): string {
+  return `${slug} [${rootName}] ${relPath}`;
+}
+
+export function registerSearch(program: Command): void {
+  program
+    .command('search [query]')
+    .description('Search projects')
+    .option('--plain', 'Print a non-interactive list')
+    .option('--json', 'Print JSON output')
+    .option('--print', 'Print selected path only')
+    .option('--limit <n>', 'Limit results', '50')
+    .action(async (query = '', options: { plain?: boolean; json?: boolean; print?: boolean; limit?: string }) => {
+      const config = await readConfig();
+      const projects = listProjects(config);
+      const matches = searchProjects(projects, query);
+      const limit = Number.parseInt(options.limit ?? '50', 10);
+      const results = Number.isNaN(limit) ? matches : matches.slice(0, limit);
+
+      if (options.json) {
+        process.stdout.write(JSON.stringify(results, null, 2));
+        process.stdout.write('\n');
+        return;
+      }
+
+      if (!process.stdin.isTTY || options.plain) {
+        if (results.length === 0) {
+          process.stdout.write('No matches.\n');
+          return;
+        }
+        for (const project of results) {
+          const rel = relativePath(project.path, project.root);
+          process.stdout.write(`${formatLabel(project.slug, project.rootName, rel)}\n`);
+        }
+        return;
+      }
+
+      const allItems: SelectEntry<typeof projects[number]>[] = projects.map((project) => {
+        const rel = relativePath(project.path, project.root);
+        return {
+          type: 'item',
+          label: formatLabel(project.slug, project.rootName, rel),
+          value: project,
+        };
+      });
+
+      const selected = await promptSearch(allItems, {
+        title: 'Search',
+        initialQuery: query,
+        maxRows: MAX_ROWS,
+        filter: (items, q) => {
+          if (!q.trim()) return items;
+          const matches = searchProjects(projects, q);
+          const matchSet = new Set(matches.map((project) => project.path));
+          return items.filter((item) => matchSet.has(item.value.path));
+        },
+      });
+      if (!selected) return;
+
+      emitSelection(selected.value, { printOnly: options.print });
+    });
+}

package/src/commands/shell.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+
+const SHELL_SNIPPET = [
+  'bet() {',
+  '  local out',
+  '  out="$(BET_EVAL=1 command bet "$@")" || return $?',
+  '  if [[ "$out" == __BET_EVAL__* ]]; then',
+  '    eval "${out#__BET_EVAL__}"',
+  '  elif [[ -n "$out" ]]; then',
+  '    printf "%s\\n" "$out"',
+  '  fi',
+  '}',
+].join('\n');
+
+export function registerShell(program: Command): void {
+  program
+    .command('shell')
+    .description('Print shell integration for cd support')
+    .action(() => {
+      process.stdout.write(`${SHELL_SNIPPET}\n`);
+    });
+}

package/src/commands/update.ts

@@ -0,0 +1,170 @@
+import path from "node:path";
+import readline from "node:readline";
+import { Command } from "commander";
+import { readConfig, resolveRoots, writeConfig } from "../lib/config.js";
+import { normalizeAbsolute } from "../utils/paths.js";
+import { installHourlyUpdateCron } from "../lib/cron.js";
+import { scanRoots } from "../lib/scan.js";
+import { computeMetadata } from "../lib/metadata.js";
+import { Config, Project, RootConfig } from "../lib/types.js";
+import { isInsideGitRepo } from "../lib/git.js";
+
+function parseRoots(value?: string): string[] | undefined {
+  if (!value) return undefined;
+  return value
+    .split(",")
+    .map((root) => root.trim())
+    .filter(Boolean);
+}
+
+function pathsToRootConfigs(paths: string[]): RootConfig[] {
+  return paths.map((p) => {
+    const abs = normalizeAbsolute(p);
+    return { path: abs, name: path.basename(abs) };
+  });
+}
+
+export function willOverrideRoots(
+  providedRootConfigs: RootConfig[] | undefined,
+  configRoots: RootConfig[],
+): boolean {
+  return !!(
+    providedRootConfigs !== undefined &&
+    configRoots.length > 0
+  );
+}
+
+function projectSlug(pathName: string): string {
+  const folderName = path.basename(pathName);
+  if (folderName === "src" || folderName === "app") {
+    return path.basename(path.dirname(pathName));
+  }
+  return folderName;
+}
+
+async function promptYesNo(question: string, defaultNo = true): Promise<boolean> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    const defaultHint = defaultNo ? "y/N" : "Y/n";
+    rl.question(question + " [" + defaultHint + "] ", (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (!trimmed) {
+        resolve(!defaultNo);
+        return;
+      }
+      resolve(trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+
+export function registerUpdate(program: Command): void {
+  program
+    .command("update")
+    .description("Scan roots and update the project index")
+    .option("--roots <paths>", "Comma-separated list of roots to scan")
+    .option("--force", "Allow overriding configured roots when not in TTY")
+    .option("--cron", "Install an hourly cron job to run bet update")
+    .action(async (options: { roots?: string; force?: boolean; cron?: boolean }) => {
+      const config = await readConfig();
+      const providedPaths = parseRoots(options.roots);
+      const providedRootConfigs = providedPaths
+        ? pathsToRootConfigs(providedPaths)
+        : undefined;
+      const configRoots = config.roots.length > 0 ? config.roots : undefined;
+      const rootsToUse = providedRootConfigs ?? configRoots;
+
+      if (!rootsToUse || rootsToUse.length === 0) {
+        process.stderr.write(
+          "Error: No roots specified. Please provide roots using --roots option.\n" +
+            "Example: bet update --roots /path/to/your/code\n",
+        );
+        process.exitCode = 1;
+        return;
+      }
+
+      const willOverride = willOverrideRoots(providedRootConfigs, config.roots);
+
+      if (willOverride) {
+        process.stderr.write(
+          "Warning: --roots will override your configured roots.\n" +
+            "  Configured: " +
+            configRoots!.map((r) => r.path).join(", ") +
+            "\n  Provided:   " +
+            providedRootConfigs!.map((r) => r.path).join(", ") +
+            "\n",
+        );
+        if (!process.stdin.isTTY) {
+          if (!options.force) {
+            process.stderr.write(
+              "Error: Refusing to override without confirmation. Run interactively or use --force.\n",
+            );
+            process.exitCode = 1;
+            return;
+          }
+        } else {
+          const confirmed = await promptYesNo("Continue?", true);
+          if (!confirmed) {
+            process.stderr.write("Aborted.\n");
+            return;
+          }
+        }
+      }
+
+      const rootsResolved = resolveRoots(rootsToUse);
+      const rootPaths = rootsResolved.map((r) => r.path);
+      const candidates = await scanRoots(rootPaths);
+      const projects: Record<string, Project> = {};
+
+      for (const candidate of candidates) {
+        const hasGit = await isInsideGitRepo(candidate.path);
+        const auto = await computeMetadata(candidate.path, hasGit);
+        const slug = projectSlug(candidate.path);
+        const existing = config.projects[candidate.path];
+        const rootConfig = rootsResolved.find((r) => r.path === candidate.root);
+        const rootName = rootConfig?.name ?? path.basename(candidate.root);
+
+        const project: Project = {
+          id: candidate.path,
+          slug,
+          name: slug,
+          path: candidate.path,
+          root: candidate.root,
+          rootName,
+          hasGit,
+          hasReadme: candidate.hasReadme,
+          auto,
+          user: existing?.user,
+        };
+
+        projects[candidate.path] = project;
+      }
+
+      const nextConfig: Config = {
+        version: config.version ?? 1,
+        roots: rootsResolved,
+        projects,
+      };
+
+      await writeConfig(nextConfig);
+
+      process.stdout.write(
+        "Indexed " +
+          Object.keys(projects).length +
+          " projects from " +
+          rootsResolved.length +
+          " root(s).\n",
+      );
+
+      if (options.cron) {
+        const entryScriptPath = path.isAbsolute(process.argv[1] ?? "")
+          ? process.argv[1]
+          : path.resolve(process.cwd(), process.argv[1] ?? "dist/index.js");
+        await installHourlyUpdateCron({
+          nodePath: process.execPath,
+          entryScriptPath,
+        });
+        process.stdout.write("Installed hourly cron job for bet update.\n");
+      }
+    });
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerUpdate } from "./commands/update.js";
+import { registerList } from "./commands/list.js";
+import { registerSearch } from "./commands/search.js";
+import { registerInfo } from "./commands/info.js";
+import { registerGo } from "./commands/go.js";
+import { registerPath } from "./commands/path.js";
+import { registerShell } from "./commands/shell.js";
+
+const program = new Command();
+
+program
+  .name("bet")
+  .description("Explore and jump between local projects.")
+  .version("0.1.0");
+
+registerUpdate(program);
+registerList(program);
+registerSearch(program);
+registerInfo(program);
+registerGo(program);
+registerPath(program);
+registerShell(program);
+
+program.parseAsync(process.argv);

package/src/lib/config.ts

@@ -0,0 +1,144 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { AppConfig, Config, ProjectsConfig, RootConfig } from "./types.js";
+import { normalizeAbsolute } from "../utils/paths.js";
+
+const CONFIG_DIR = process.env.XDG_CONFIG_HOME
+  ? path.join(process.env.XDG_CONFIG_HOME, "bet")
+  : path.join(os.homedir(), ".config", "bet");
+
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+const PROJECTS_PATH = path.join(CONFIG_DIR, "projects.json");
+
+const DEFAULT_APP_CONFIG: AppConfig = {
+  version: 1,
+  roots: [],
+};
+
+const DEFAULT_PROJECTS_CONFIG: ProjectsConfig = {
+  projects: {},
+};
+
+const DEFAULT_CONFIG: Config = {
+  ...DEFAULT_APP_CONFIG,
+  ...DEFAULT_PROJECTS_CONFIG,
+};
+
+export function getConfigPath(): string {
+  return CONFIG_PATH;
+}
+
+export function getProjectsPath(): string {
+  return PROJECTS_PATH;
+}
+
+function normalizeRoots(parsedRoots: unknown): RootConfig[] {
+  if (!Array.isArray(parsedRoots)) return [];
+  const result: RootConfig[] = [];
+  for (const r of parsedRoots) {
+    if (typeof r === "string") {
+      const abs = normalizeAbsolute(r);
+      result.push({ path: abs, name: path.basename(abs) });
+    } else if (r && typeof r === "object" && "path" in r && typeof (r as RootConfig).path === "string") {
+      const root = r as RootConfig;
+      const abs = normalizeAbsolute(root.path);
+      const name = (root.name?.trim() || path.basename(abs));
+      result.push({ path: abs, name });
+    }
+  }
+  return result;
+}
+
+async function readAppConfig(): Promise<AppConfig> {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw) as { version?: number; roots?: unknown };
+    const roots = normalizeRoots(parsed.roots ?? []);
+    return {
+      ...DEFAULT_APP_CONFIG,
+      version: parsed.version ?? 1,
+      roots,
+    };
+  } catch (error) {
+    return { ...DEFAULT_APP_CONFIG };
+  }
+}
+
+async function readProjectsConfig(): Promise<ProjectsConfig> {
+  try {
+    const raw = await fs.readFile(PROJECTS_PATH, "utf8");
+    const parsed = JSON.parse(raw) as ProjectsConfig;
+    return {
+      projects: parsed.projects ?? {},
+    };
+  } catch (error) {
+    return { ...DEFAULT_PROJECTS_CONFIG };
+  }
+}
+
+function normalizeProjectRootName(project: { root: string; rootName?: string; group?: string }, roots: RootConfig[]): string {
+  if (project.rootName?.trim()) return project.rootName.trim();
+  const matched = roots.find((r) => r.path === project.root);
+  if (matched) return matched.name;
+  return path.basename(project.root);
+}
+
+export async function readConfig(): Promise<Config> {
+  const [appConfig, projectsConfig] = await Promise.all([
+    readAppConfig(),
+    readProjectsConfig(),
+  ]);
+  const projects = projectsConfig.projects;
+  const normalizedProjects: Record<string, import("./types.js").Project> = {};
+  for (const [id, p] of Object.entries(projects)) {
+    const rootName = normalizeProjectRootName(p, appConfig.roots);
+    const { group: _group, ...rest } = p as import("./types.js").Project & { group?: string };
+    normalizedProjects[id] = { ...rest, rootName } as import("./types.js").Project;
+  }
+  return {
+    ...appConfig,
+    projects: normalizedProjects,
+  };
+}
+
+async function writeAppConfig(appConfig: AppConfig): Promise<void> {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  const formatted = JSON.stringify(appConfig, null, 2);
+  await fs.writeFile(CONFIG_PATH, formatted, "utf8");
+}
+
+async function writeProjectsConfig(
+  projectsConfig: ProjectsConfig,
+): Promise<void> {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  const formatted = JSON.stringify(projectsConfig, null, 2);
+  await fs.writeFile(PROJECTS_PATH, formatted, "utf8");
+}
+
+export async function writeConfig(config: Config): Promise<void> {
+  const appConfig: AppConfig = {
+    version: config.version,
+    roots: config.roots,
+  };
+  const projectsConfig: ProjectsConfig = {
+    projects: config.projects,
+  };
+  await Promise.all([
+    writeAppConfig(appConfig),
+    writeProjectsConfig(projectsConfig),
+  ]);
+}
+
+export function resolveRoots(inputRoots: RootConfig[]): RootConfig[] {
+  const seen = new Set<string>();
+  const resolved: RootConfig[] = [];
+  for (const root of inputRoots) {
+    const abs = normalizeAbsolute(root.path);
+    if (!seen.has(abs)) {
+      seen.add(abs);
+      resolved.push({ path: abs, name: root.name?.trim() || path.basename(abs) });
+    }
+  }
+  return resolved;
+}