bet-cli 0.1.0

package/dist/commands/shell.js

@@ -0,0 +1,19 @@
+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) {
+    program
+        .command('shell')
+        .description('Print shell integration for cd support')
+        .action(() => {
+        process.stdout.write(`${SHELL_SNIPPET}\n`);
+    });
+}

package/dist/commands/update.js

@@ -0,0 +1,140 @@
+import path from "node:path";
+import readline from "node:readline";
+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 { isInsideGitRepo } from "../lib/git.js";
+function parseRoots(value) {
+    if (!value)
+        return undefined;
+    return value
+        .split(",")
+        .map((root) => root.trim())
+        .filter(Boolean);
+}
+function pathsToRootConfigs(paths) {
+    return paths.map((p) => {
+        const abs = normalizeAbsolute(p);
+        return { path: abs, name: path.basename(abs) };
+    });
+}
+export function willOverrideRoots(providedRootConfigs, configRoots) {
+    return !!(providedRootConfigs !== undefined &&
+        configRoots.length > 0);
+}
+function projectSlug(pathName) {
+    const folderName = path.basename(pathName);
+    if (folderName === "src" || folderName === "app") {
+        return path.basename(path.dirname(pathName));
+    }
+    return folderName;
+}
+async function promptYesNo(question, defaultNo = true) {
+    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) {
+    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) => {
+        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 = {};
+        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 = {
+                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 = {
+            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/dist/index.js

@@ -0,0 +1,22 @@
+#!/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/dist/lib/config.js

@@ -0,0 +1,131 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+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 = {
+    version: 1,
+    roots: [],
+};
+const DEFAULT_PROJECTS_CONFIG = {
+    projects: {},
+};
+const DEFAULT_CONFIG = {
+    ...DEFAULT_APP_CONFIG,
+    ...DEFAULT_PROJECTS_CONFIG,
+};
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export function getProjectsPath() {
+    return PROJECTS_PATH;
+}
+function normalizeRoots(parsedRoots) {
+    if (!Array.isArray(parsedRoots))
+        return [];
+    const result = [];
+    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.path === "string") {
+            const root = r;
+            const abs = normalizeAbsolute(root.path);
+            const name = (root.name?.trim() || path.basename(abs));
+            result.push({ path: abs, name });
+        }
+    }
+    return result;
+}
+async function readAppConfig() {
+    try {
+        const raw = await fs.readFile(CONFIG_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const roots = normalizeRoots(parsed.roots ?? []);
+        return {
+            ...DEFAULT_APP_CONFIG,
+            version: parsed.version ?? 1,
+            roots,
+        };
+    }
+    catch (error) {
+        return { ...DEFAULT_APP_CONFIG };
+    }
+}
+async function readProjectsConfig() {
+    try {
+        const raw = await fs.readFile(PROJECTS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            projects: parsed.projects ?? {},
+        };
+    }
+    catch (error) {
+        return { ...DEFAULT_PROJECTS_CONFIG };
+    }
+}
+function normalizeProjectRootName(project, roots) {
+    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() {
+    const [appConfig, projectsConfig] = await Promise.all([
+        readAppConfig(),
+        readProjectsConfig(),
+    ]);
+    const projects = projectsConfig.projects;
+    const normalizedProjects = {};
+    for (const [id, p] of Object.entries(projects)) {
+        const rootName = normalizeProjectRootName(p, appConfig.roots);
+        const { group: _group, ...rest } = p;
+        normalizedProjects[id] = { ...rest, rootName };
+    }
+    return {
+        ...appConfig,
+        projects: normalizedProjects,
+    };
+}
+async function writeAppConfig(appConfig) {
+    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) {
+    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) {
+    const appConfig = {
+        version: config.version,
+        roots: config.roots,
+    };
+    const projectsConfig = {
+        projects: config.projects,
+    };
+    await Promise.all([
+        writeAppConfig(appConfig),
+        writeProjectsConfig(projectsConfig),
+    ]);
+}
+export function resolveRoots(inputRoots) {
+    const seen = new Set();
+    const resolved = [];
+    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;
+}

package/dist/lib/cron.js

@@ -0,0 +1,73 @@
+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";
+/**
+ * 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) {
+    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 = [];
+    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/dist/lib/git.js

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

package/dist/lib/ignore.js

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

package/dist/lib/metadata.js

@@ -0,0 +1,37 @@
+import fg from 'fast-glob';
+import { DEFAULT_IGNORES } from './ignore.js';
+import { getDirtyStatus, getFirstCommitDate } from './git.js';
+import { readReadmeDescription } from './readme.js';
+export async function computeMetadata(projectPath, hasGit) {
+    const nowIso = new Date().toISOString();
+    const entries = await fg('**/*', {
+        cwd: projectPath,
+        dot: true,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+        ignore: DEFAULT_IGNORES,
+        stats: true,
+    });
+    let oldest;
+    let newest;
+    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/dist/lib/projects.js

@@ -0,0 +1,15 @@
+export function listProjects(config) {
+    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) {
+    return `${project.rootName}/${project.slug}`;
+}
+export function findBySlug(projects, slug) {
+    const normalized = slug.trim().toLowerCase();
+    return projects.filter((project) => project.slug.toLowerCase() === normalized);
+}

package/dist/lib/readme.js

@@ -0,0 +1,70 @@
+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) {
+    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) {
+    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) {
+    const readmePath = await readReadmePath(projectPath);
+    if (!readmePath)
+        return undefined;
+    const raw = await fs.readFile(readmePath, "utf8");
+    const lines = raw.split(/\r?\n/);
+    let title;
+    let paragraph = [];
+    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/dist/lib/scan.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import fg from "fast-glob";
+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) {
+    const container = path.dirname(matchPath);
+    // if (
+    //   path.basename(container) === "src" ||
+    //   path.basename(container) === "app"
+    // ) {
+    //   return path.dirname(container);
+    // }
+    return container;
+}
+function addCandidate(map, projectPath, root, flags) {
+    const existing = map.get(projectPath);
+    const base = existing ?? {
+        path: projectPath,
+        root,
+        hasGit: false,
+        hasReadme: false,
+    };
+    const next = {
+        ...base,
+        ...flags,
+    };
+    if (existing && root.length > existing.root.length) {
+        next.root = root;
+    }
+    map.set(projectPath, next);
+}
+export async function scanRoots(roots) {
+    const candidates = new Map();
+    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 = [];
+    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/dist/lib/search.js

@@ -0,0 +1,20 @@
+import Fuse from 'fuse.js';
+export function searchProjects(projects, query) {
+    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/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/markdown.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+const renderer = new TerminalRenderer();
+export function Markdown({ content }) {
+    marked.setOptions({ renderer });
+    const output = marked.parse(content).trim();
+    return _jsx(Text, { children: output });
+}