bet-cli 0.1.4 → 0.3.0

package/src/lib/config.ts

@@ -68,11 +68,25 @@ function normalizeIgnoredPaths(parsed: unknown): string[] | undefined {
   return list.length === 0 ? undefined : list;
 }
 
+function normalizeEditor(parsed: unknown): string | undefined {
+  if (typeof parsed !== "string") return undefined;
+  const trimmed = parsed.trim();
+  return trimmed.length === 0 ? undefined : trimmed;
+}
+
 async function readAppConfig(): Promise<AppConfig> {
   try {
     const raw = await fs.readFile(CONFIG_PATH, "utf8");
-    const parsed = JSON.parse(raw) as { version?: number; roots?: unknown; ignores?: unknown; ignoredPaths?: unknown; slugParentFolders?: unknown };
+    const parsed = JSON.parse(raw) as {
+      version?: number;
+      roots?: unknown;
+      editor?: unknown;
+      ignores?: unknown;
+      ignoredPaths?: unknown;
+      slugParentFolders?: unknown;
+    };
     const roots = normalizeRoots(parsed.roots ?? []);
+    const editor = normalizeEditor(parsed.editor);
     const ignores = normalizeIgnores(parsed.ignores);
     const ignoredPaths = normalizeIgnoredPaths(parsed.ignoredPaths);
     const slugParentFolders = normalizeSlugParentFolders(parsed.slugParentFolders);
@@ -80,6 +94,7 @@ async function readAppConfig(): Promise<AppConfig> {
       ...DEFAULT_APP_CONFIG,
       version: parsed.version ?? 1,
       roots,
+      ...(editor !== undefined && { editor }),
       ...(ignores !== undefined && { ignores }),
       ...(ignoredPaths !== undefined && { ignoredPaths }),
       ...(slugParentFolders !== undefined && { slugParentFolders }),
@@ -95,6 +110,7 @@ async function readProjectsConfig(): Promise<ProjectsConfig> {
     const parsed = JSON.parse(raw) as ProjectsConfig;
     return {
       projects: parsed.projects ?? {},
+      ...(parsed.updatedAt != null && typeof parsed.updatedAt === "string" && { updatedAt: parsed.updatedAt }),
     };
   } catch (error) {
     return { ...DEFAULT_PROJECTS_CONFIG };
@@ -123,6 +139,7 @@ export async function readConfig(): Promise<Config> {
   return {
     ...appConfig,
     projects: normalizedProjects,
+    ...(projectsConfig.updatedAt != null && { updatedAt: projectsConfig.updatedAt }),
   };
 }
 
@@ -144,12 +161,14 @@ export async function writeConfig(config: Config): Promise<void> {
   const appConfig: AppConfig = {
     version: config.version,
     roots: config.roots,
+    ...(config.editor !== undefined && { editor: config.editor }),
     ...(config.ignores !== undefined && { ignores: config.ignores }),
     ...(config.ignoredPaths !== undefined && { ignoredPaths: config.ignoredPaths }),
     ...(config.slugParentFolders !== undefined && { slugParentFolders: config.slugParentFolders }),
   };
   const projectsConfig: ProjectsConfig = {
     projects: config.projects,
+    ...(config.updatedAt !== undefined && { updatedAt: config.updatedAt }),
   };
   await Promise.all([
     writeAppConfig(appConfig),

package/src/lib/editor.ts

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+
+export type LaunchCommand = {
+  command: string;
+  args: string[];
+};
+
+function tokenizeCommand(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (const char of input) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+
+    if (char === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+
+    if (char === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+
+    if (!inSingle && !inDouble && /\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (escaped || inSingle || inDouble) {
+    throw new Error("Invalid editor command in config.");
+  }
+
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+
+  return tokens;
+}
+
+export function parseEditorCommand(editor: string): LaunchCommand {
+  const trimmed = editor.trim();
+  if (!trimmed) {
+    throw new Error("Config editor must not be empty.");
+  }
+
+  const tokens = tokenizeCommand(trimmed);
+  if (tokens.length === 0) {
+    throw new Error("Config editor must not be empty.");
+  }
+
+  const [command, ...args] = tokens;
+  return { command, args };
+}
+
+export function getSystemOpenCommand(
+  targetPath: string,
+  platform: NodeJS.Platform = process.platform,
+): LaunchCommand {
+  if (platform === "darwin") {
+    return { command: "open", args: [targetPath] };
+  }
+
+  if (platform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", targetPath] };
+  }
+
+  return { command: "xdg-open", args: [targetPath] };
+}
+
+function getEnvEditor(env: NodeJS.ProcessEnv): string | undefined {
+  const visual = env.VISUAL?.trim();
+  if (visual) return visual;
+
+  const editor = env.EDITOR?.trim();
+  if (editor) return editor;
+
+  return undefined;
+}
+
+function spawnDetached(command: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+    });
+
+    child.once("error", (error) => {
+      reject(error);
+    });
+
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+export async function openProjectInEditor(
+  projectPath: string,
+  configuredEditor?: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  const preferredEditor = configuredEditor?.trim() || getEnvEditor(env);
+  if (preferredEditor) {
+    const parsed = parseEditorCommand(preferredEditor);
+    await spawnDetached(parsed.command, [...parsed.args, projectPath]);
+    return;
+  }
+
+  const fallback = getSystemOpenCommand(projectPath);
+  await spawnDetached(fallback.command, fallback.args);
+}

package/src/lib/git.ts

@@ -1,12 +1,12 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+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',
+    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
     });
     return stdout.trim();
   } catch {
@@ -14,18 +14,28 @@ async function runGit(cwd: string, args: string[]): Promise<string | null> {
   }
 }
 
-export async function getFirstCommitDate(cwd: string): Promise<string | undefined> {
-  const output = await runGit(cwd, ['log', '--reverse', '--format=%cI', '-n', '1']);
+export async function getFirstCommitDate(
+  cwd: string,
+): Promise<string | undefined> {
+  const output = await runGit(cwd, [
+    "log",
+    "--max-parents=0",
+    "--format=%cd",
+    "--date=iso-strict",
+    "HEAD",
+  ]);
   return output || undefined;
 }
 
-export async function getDirtyStatus(cwd: string): Promise<boolean | undefined> {
-  const output = await runGit(cwd, ['status', '--porcelain']);
+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';
+  const output = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  return output === "true";
 }

package/src/lib/help.ts

@@ -1,7 +1,7 @@
 import { Help } from "commander";
 import type { Command } from "commander";
 
-const GROUP_1: string[] = ["list", "search", "info", "go", "path"];
+const GROUP_1: string[] = ["list", "search", "info", "go", "edit", "path"];
 const GROUP_2: string[] = ["shell", "completion"];
 const GROUP_3: string[] = ["update", "ignore", "help"];
 
@@ -55,23 +55,24 @@ export class GroupedHelp extends Help {
     }
 
     // Arguments
-    const argumentList = helper.visibleArguments(cmd).map((argument) =>
-      formatItem(
-        helper.argumentTerm(argument),
-        helper.argumentDescription(argument),
-      ),
-    );
+    const argumentList = helper
+      .visibleArguments(cmd)
+      .map((argument) =>
+        formatItem(
+          helper.argumentTerm(argument),
+          helper.argumentDescription(argument),
+        ),
+      );
     if (argumentList.length > 0) {
       output.push("Arguments:", formatList(argumentList), "");
     }
 
     // Options
-    const optionList = helper.visibleOptions(cmd).map((option) =>
-      formatItem(
-        helper.optionTerm(option),
-        helper.optionDescription(option),
-      ),
-    );
+    const optionList = helper
+      .visibleOptions(cmd)
+      .map((option) =>
+        formatItem(helper.optionTerm(option), helper.optionDescription(option)),
+      );
     if (optionList.length > 0) {
       output.push("Options:", formatList(optionList), "");
     }
@@ -105,8 +106,7 @@ export class GroupedHelp extends Help {
       const groupIndices = [...byGroup.keys()].sort((a, b) => a - b);
       for (const idx of groupIndices) {
         const commands = byGroup.get(idx)!;
-        const heading =
-          idx < GROUPS.length ? GROUPS[idx].heading : "Commands";
+        const heading = idx < GROUPS.length ? GROUPS[idx].heading : "Commands";
         const commandList = commands.map((sub) =>
           formatItem(
             helper.subcommandTerm(sub),

package/src/lib/readme.ts

@@ -20,6 +20,7 @@ export async function readReadmePath(
 
 export async function readReadmeContent(
   projectPath: string,
+  options?: { full?: boolean },
 ): Promise<string | undefined> {
   const readmePath = await readReadmePath(projectPath);
   if (!readmePath) return undefined;
@@ -28,7 +29,11 @@ export async function readReadmeContent(
   // remove html tags
   content = content.replace(/<[^>]*>?/g, "");
 
-  // only graph the first 300 characters, and add ... if there are more
+  if (options?.full) {
+    return content;
+  }
+
+  // only grab the first 500 characters, and add ... if there are more
   const truncated = content.slice(0, 500);
   if (content.length > 500) {
     return `${truncated}...`;

package/src/lib/types.ts

@@ -33,6 +33,7 @@ export type RootConfig = {
 export type AppConfig = {
   version: number;
   roots: RootConfig[];
+  editor?: string;
   ignores?: string[];
   ignoredPaths?: string[];
   slugParentFolders?: string[];
@@ -40,15 +41,18 @@ export type AppConfig = {
 
 export type ProjectsConfig = {
   projects: Record<string, Project>;
+  updatedAt?: string;
 };
 
 export type Config = {
   version: number;
   roots: RootConfig[];
+  editor?: string;
   ignores?: string[];
   ignoredPaths?: string[];
   slugParentFolders?: string[];
   projects: Record<string, Project>;
+  updatedAt?: string;
 };
 
 export type ProjectCandidate = {

package/src/main.ts

@@ -0,0 +1,57 @@
+import { Command } from "commander";
+import { GroupedHelp } from "./lib/help.js";
+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";
+import { registerCompletion } from "./commands/completion.js";
+import { registerIgnore } from "./commands/ignore.js";
+import { registerEdit } from "./commands/edit.js";
+
+const ASCII_HEADER = `
+                            ░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░
+                        ░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░
+                    ░░░░░░░░░░░░░   ░░░░░░                                 ░░░░░░
+                ░░░░░░░░░░░░░░░░░   ░░░░░░                                 ░░░░░░
+            ░░░░░░░░░░░░░   ░░░░░   ░░░░░░                                 ░░░░░░
+        ░░░░░░░░░░░░░       ░░░░░   ░░░░░░                                 ░░░░░░
+      ░░░░░░░░░░░░          ░░░░░   ░░░░░░                                 ░░░░░░
+         ░░░░░░░░░░░░░░░░   ░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░             ░░░░░░
+              ░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░             ░░░░░░
+                   ░░░░░░░░░░░░░░   ░░░░░░                                 ░░░░░░
+                        ░░░░░░░░░   ░░░░░░                                 ░░░░░░
+                            ░░░░░   ░░░░░░                                 ░░░░░░
+                            ░░░░░   ░░░░░░                                 ░░░░░░
+                            ░░░░░   ░░░░░░                                 ░░░░░░
+       ░░░░░░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░             ░░░░░░
+       ░░░░░░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░░░░░             ░░░░░░
+`;
+
+const program = new Command();
+
+program.createHelp = function createHelp(this: Command) {
+  return Object.assign(new GroupedHelp(), this.configureHelp());
+};
+
+program
+  .name("bet")
+  .description("Explore and jump between local projects.")
+  .version("0.3.0");
+
+registerUpdate(program);
+registerList(program);
+registerSearch(program);
+registerInfo(program);
+registerGo(program);
+registerEdit(program);
+registerPath(program);
+registerShell(program);
+registerCompletion(program);
+registerIgnore(program);
+
+program.addHelpText("before", ASCII_HEADER);
+
+program.parseAsync(process.argv);

package/src/ui/markdown.tsx

@@ -0,0 +1,14 @@
+import { Text } from "ink";
+import { marked, type MarkedExtension } from "marked";
+import { markedTerminal, type TerminalRendererOptions } from "marked-terminal";
+import React from "react";
+
+export type Props = TerminalRendererOptions & {
+  children: string;
+};
+
+export default function Markdown({ children, ...options }: Props) {
+  marked.use(markedTerminal(options) as MarkedExtension);
+  const parsedMarkdown = marked.parse(children, { async: false }) as string;
+  return React.createElement(Text, null, parsedMarkdown.trim());
+}

package/src/ui/search.tsx

@@ -1,5 +1,4 @@
 import React, { useMemo, useState } from 'react';
-import chalk from 'chalk';
 import { Box, Text, useInput } from 'ink';
 import { SelectEntry } from './select.js';
 
@@ -67,10 +66,22 @@ export function SearchSelect<T>({
 
   if (items.length === 0) {
     return (
-      <Box flexDirection="column">
-        {title && <Text>{chalk.bold(title)}</Text>}
-        <Text>{`Search: ${query}`}</Text>
-        <Text>No results.</Text>
+      <Box flexDirection="column" borderStyle="round" borderColor="magenta" padding={1}>
+        {title ? (
+          <Box marginBottom={1}>
+            <Text bold color="cyan">
+              {title}
+            </Text>
+          </Box>
+        ) : null}
+        <Box marginBottom={1} flexDirection="row">
+          <Text bold color="yellow">Search: </Text>
+          <Text color="cyan">{query || '…'}</Text>
+        </Box>
+        <Text color="yellow">No results.</Text>
+        <Box marginTop={1}>
+          <Text color="gray">Press Esc to exit.</Text>
+        </Box>
       </Box>
     );
   }
@@ -86,25 +97,45 @@ export function SearchSelect<T>({
   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 flexDirection="column" borderStyle="round" borderColor="magenta" padding={1}>
+      {title ? (
+        <Box marginBottom={1}>
+          <Text bold color="cyan">
+            {title}
+          </Text>
+        </Box>
+      ) : null}
+      <Box marginBottom={1} flexDirection="row">
+        <Text bold color="yellow">Search: </Text>
+        <Text color="green">{query || '…'}</Text>
+        {showCount ? (
+          <Text color="cyan"> · {items.length} result{items.length !== 1 ? 's' : ''}</Text>
+        ) : null}
+      </Box>
+      <Box flexDirection="column">
+        {windowed.map((row, idx) => {
+          const absoluteIndex = windowStart + idx;
+          const selected = absoluteIndex === selectedRowIndex;
+          return (
+            <Box key={`item-${absoluteIndex}`} flexDirection="row">
+              <Text color={selected ? 'green' : undefined} bold={selected}>
+                {selected ? '› ' : '  '}
+                {row.label}
+              </Text>
+              {row.hint ? <Text color="gray"> {row.hint}</Text> : null}
+            </Box>
+          );
+        })}
+      </Box>
+      <Box marginTop={1} flexDirection="row">
+        <Text color="yellow">Type to filter</Text>
+        <Text color="gray"> · </Text>
+        <Text color="yellow">↑/↓ or j/k</Text>
+        <Text color="gray"> · </Text>
+        <Text color="green">Enter</Text>
+        <Text color="gray"> to select · </Text>
+        <Text color="red">Esc</Text>
+        <Text color="gray"> to cancel</Text>
       </Box>
     </Box>
   );

package/src/ui/select.tsx

@@ -1,5 +1,4 @@
 import React, { useMemo, useState } from 'react';
-import chalk from 'chalk';
 import { Box, Text, useInput } from 'ink';
 
 export type SelectGroup = {
@@ -65,11 +64,17 @@ export function SelectList<T>({
 
   if (items.length === 0) {
     return (
-      <Box flexDirection="column">
-        {title && <Text>{chalk.bold(title)}</Text>}
-        <Text>No results.</Text>
+      <Box flexDirection="column" borderStyle="round" borderColor="magenta" padding={1}>
+        {title ? (
+          <Box marginBottom={1}>
+            <Text bold color="cyan">
+              {title}
+            </Text>
+          </Box>
+        ) : null}
+        <Text color="yellow">No results.</Text>
         <Box marginTop={1}>
-        <Text>{chalk.dim('Press Esc to exit.')}</Text>
+          <Text color="gray">Press Esc to exit.</Text>
         </Box>
       </Box>
     );
@@ -86,33 +91,49 @@ export function SelectList<T>({
   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;
+    <Box flexDirection="column" borderStyle="round" borderColor="magenta" padding={1}>
+      {title ? (
+        <Box marginBottom={1}>
+          <Text bold color="cyan">
+            {title}
+          </Text>
+        </Box>
+      ) : null}
+      <Box flexDirection="column">
+        {windowed.map((row, idx) => {
+          const absoluteIndex = windowStart + idx;
+          const selected = row.type === 'item' && absoluteIndex === selectedRowIndex;
+
+          if (row.type === 'group') {
+            return (
+              <Box key={`group-${absoluteIndex}`} marginTop={idx === 0 ? 0 : 1}>
+                <Text bold color={row.color ?? 'cyan'}>
+                  [{row.label}]
+                </Text>
+              </Box>
+            );
+          }
 
-        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 key={`item-${absoluteIndex}`} flexDirection="row">
+              <Text color={selected ? 'green' : undefined} bold={selected}>
+                {selected ? '› ' : '  '}
+                {row.label}
+              </Text>
+              {row.hint ? (
+                <Text color="gray"> {row.hint}</Text>
+              ) : null}
             </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>
       <Box marginTop={1}>
-        <Text>{chalk.dim('Use ↑/↓ or j/k. Enter to select. Esc to cancel.')}</Text>
+        <Text color="yellow">↑/↓ or j/k</Text>
+        <Text color="gray"> · </Text>
+        <Text color="green">Enter</Text>
+        <Text color="gray"> to select · </Text>
+        <Text color="red">Esc</Text>
+        <Text color="gray"> to cancel</Text>
       </Box>
     </Box>
   );