arbors 0.1.0

package/src/project/registry.ts

@@ -0,0 +1,108 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { RuntimeAdapter } from "../runtime/adapter.js";
+
+export interface ProjectEntry {
+  name: string;
+  path: string;
+  lastAccessed: string;
+}
+
+export interface WorktreeEntry {
+  path: string;
+  branch: string;
+  projectPath: string;
+}
+
+interface RegistryData {
+  projects: ProjectEntry[];
+  worktrees: WorktreeEntry[];
+}
+
+const DB_PATH = join(homedir(), ".arbors", "db.json");
+
+const readRegistry = async (adapter: RuntimeAdapter): Promise<RegistryData> => {
+  if (!(await adapter.exists(DB_PATH))) return { projects: [], worktrees: [] };
+
+  try {
+    const content = await adapter.readFile(DB_PATH);
+    const data = JSON.parse(content) as Partial<RegistryData>;
+    return { projects: data.projects ?? [], worktrees: data.worktrees ?? [] };
+  } catch {
+    return { projects: [], worktrees: [] };
+  }
+};
+
+const writeRegistry = async (adapter: RuntimeAdapter, data: RegistryData): Promise<void> => {
+  await adapter.writeFile(DB_PATH, JSON.stringify(data, null, 2));
+};
+
+export const getProjects = async (adapter: RuntimeAdapter): Promise<ProjectEntry[]> =>
+  (await readRegistry(adapter)).projects.toSorted(
+    (a, b) => new Date(b.lastAccessed).getTime() - new Date(a.lastAccessed).getTime(),
+  );
+
+export const registerProject = async (
+  adapter: RuntimeAdapter,
+  name: string,
+  path: string,
+): Promise<void> => {
+  const data = await readRegistry(adapter);
+  const now = new Date().toISOString();
+
+  const existing = data.projects.findIndex((p) => p.path === path);
+
+  if (existing !== -1) {
+    data.projects[existing] = { ...data.projects[existing], lastAccessed: now };
+  } else {
+    data.projects.push({ name, path, lastAccessed: now });
+  }
+
+  await writeRegistry(adapter, data);
+};
+
+export const touchProject = async (adapter: RuntimeAdapter, path: string): Promise<void> => {
+  const data = await readRegistry(adapter);
+  const entry = data.projects.find((p) => p.path === path);
+
+  if (entry) {
+    entry.lastAccessed = new Date().toISOString();
+    await writeRegistry(adapter, data);
+  }
+};
+
+export const removeProject = async (adapter: RuntimeAdapter, path: string): Promise<void> => {
+  const data = await readRegistry(adapter);
+  data.projects = data.projects.filter((p) => p.path !== path);
+  await writeRegistry(adapter, data);
+};
+
+export const registerWorktree = async (
+  adapter: RuntimeAdapter,
+  path: string,
+  branch: string,
+  projectPath: string,
+): Promise<void> => {
+  const data = await readRegistry(adapter);
+  const existing = data.worktrees.findIndex((w) => w.path === path);
+
+  if (existing === -1) {
+    data.worktrees.push({ path, branch, projectPath });
+  }
+
+  await writeRegistry(adapter, data);
+};
+
+export const getWorktrees = async (
+  adapter: RuntimeAdapter,
+  projectPath: string,
+): Promise<WorktreeEntry[]> => {
+  const data = await readRegistry(adapter);
+  return data.worktrees.filter((w) => w.projectPath === projectPath);
+};
+
+export const unregisterWorktree = async (adapter: RuntimeAdapter, path: string): Promise<void> => {
+  const data = await readRegistry(adapter);
+  data.worktrees = data.worktrees.filter((w) => w.path !== path);
+  await writeRegistry(adapter, data);
+};

package/src/project/setup.ts

@@ -0,0 +1,74 @@
+import { join } from "node:path";
+import type { RuntimeAdapter } from "../runtime/adapter.js";
+
+type PackageManager = "pnpm" | "yarn" | "npm" | null;
+type RuntimeManager = "mise" | "nvm" | null;
+
+const LOCK_FILE_MAP: [string, PackageManager][] = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"],
+];
+
+const RUNTIME_MANAGER_MAP: [string, RuntimeManager][] = [
+  ["mise.toml", "mise"],
+  [".mise.toml", "mise"],
+  [".nvmrc", "nvm"],
+];
+
+const detectFile = async <T>(
+  adapter: RuntimeAdapter,
+  cwd: string,
+  entries: [string, T][],
+): Promise<T | null> => {
+  const results = await Promise.all(
+    entries.map(async ([file, value]) => ({
+      value,
+      exists: await adapter.exists(join(cwd, file)),
+    })),
+  );
+
+  return results.find((r) => r.exists)?.value ?? null;
+};
+
+export const detectPackageManager = async (
+  adapter: RuntimeAdapter,
+  cwd: string,
+): Promise<PackageManager> => detectFile(adapter, cwd, LOCK_FILE_MAP);
+
+export const detectRuntimeManager = async (
+  adapter: RuntimeAdapter,
+  cwd: string,
+): Promise<RuntimeManager> => detectFile(adapter, cwd, RUNTIME_MANAGER_MAP);
+
+const PM_INSTALL_ARGS: Record<string, string[]> = {
+  pnpm: ["install"],
+  yarn: ["install"],
+  npm: ["install"],
+};
+
+const RM_INSTALL_ARGS: Record<string, [string, string[]]> = {
+  mise: ["mise", ["install"]],
+  nvm: ["bash", ["-c", "source ~/.nvm/nvm.sh && nvm install"]],
+};
+
+export const runSetup = async (
+  adapter: RuntimeAdapter,
+  cwd: string,
+  configPm?: "auto" | "pnpm" | "yarn" | "npm",
+): Promise<{ packageManager: string | null; runtimeManager: string | null }> => {
+  const rm = await detectRuntimeManager(adapter, cwd);
+
+  if (rm) {
+    const [cmd, args] = RM_INSTALL_ARGS[rm];
+    await adapter.exec(cmd, args);
+  }
+
+  const pm = configPm && configPm !== "auto" ? configPm : await detectPackageManager(adapter, cwd);
+
+  if (pm) {
+    await adapter.exec(pm, PM_INSTALL_ARGS[pm]);
+  }
+
+  return { packageManager: pm, runtimeManager: rm };
+};

package/src/runtime/adapter.ts

@@ -0,0 +1,16 @@
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface RuntimeAdapter {
+  /** Run a command with arguments (no shell, safe from injection) */
+  exec(cmd: string, args: string[]): Promise<ExecResult>;
+  glob(pattern: string, cwd: string): Promise<string[]>;
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  copy(src: string, dest: string): Promise<void>;
+  mkdir(path: string): Promise<void>;
+}

package/src/runtime/bun.ts

@@ -0,0 +1,49 @@
+import { dirname } from "node:path";
+import type { RuntimeAdapter } from "./adapter.js";
+
+export const createBunAdapter = (): RuntimeAdapter => ({
+  async exec(cmd, args) {
+    const proc = Bun.spawn([cmd, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    return { stdout: stdout.trimEnd(), stderr: stderr.trimEnd(), exitCode };
+  },
+
+  async glob(pattern, cwd) {
+    const bunGlob = new Bun.Glob(pattern);
+    const matches: string[] = [];
+    for await (const entry of bunGlob.scan({ cwd })) {
+      matches.push(entry);
+    }
+    return matches.sort();
+  },
+
+  async readFile(path) {
+    return Bun.file(path).text();
+  },
+
+  async writeFile(path, content) {
+    await Bun.write(path, content);
+  },
+
+  async exists(path) {
+    return Bun.file(path).exists();
+  },
+
+  async copy(src, dest) {
+    const { cp, mkdir } = await import("node:fs/promises");
+    await mkdir(dirname(dest), { recursive: true });
+    await cp(src, dest, { recursive: true });
+  },
+
+  async mkdir(path) {
+    const { mkdir } = await import("node:fs/promises");
+    await mkdir(path, { recursive: true });
+  },
+});

package/src/runtime/index.ts

@@ -0,0 +1,17 @@
+import type { RuntimeAdapter } from "./adapter.js";
+
+export type { ExecResult, RuntimeAdapter } from "./adapter.js";
+
+const isBun = (): boolean => Object.hasOwn(process.versions, "bun");
+
+export const createAdapter = async (runtime?: "bun" | "node"): Promise<RuntimeAdapter> => {
+  const resolved = runtime ?? (isBun() ? "bun" : "node");
+
+  if (resolved === "bun") {
+    const { createBunAdapter } = await import("./bun.js");
+    return createBunAdapter();
+  }
+
+  const { createNodeAdapter } = await import("./node.js");
+  return createNodeAdapter();
+};

package/src/runtime/node.ts

@@ -0,0 +1,58 @@
+import { execFile } from "node:child_process";
+import { cp, glob, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { promisify } from "node:util";
+import type { RuntimeAdapter } from "./adapter.js";
+
+const execFileAsync = promisify(execFile);
+
+export const createNodeAdapter = (): RuntimeAdapter => ({
+  async exec(cmd, args) {
+    try {
+      const { stdout, stderr } = await execFileAsync(cmd, args);
+      return { stdout: stdout.trimEnd(), stderr: stderr.trimEnd(), exitCode: 0 };
+    } catch (error: unknown) {
+      const err = error as { stdout?: string; stderr?: string; code?: number };
+      return {
+        stdout: (err.stdout ?? "").trimEnd(),
+        stderr: (err.stderr ?? "").trimEnd(),
+        exitCode: err.code ?? 1,
+      };
+    }
+  },
+
+  async glob(pattern, cwd) {
+    const matches: string[] = [];
+    for await (const entry of glob(pattern, { cwd })) {
+      matches.push(entry);
+    }
+    return matches.sort();
+  },
+
+  async readFile(path) {
+    return readFile(path, "utf-8");
+  },
+
+  async writeFile(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, "utf-8");
+  },
+
+  async exists(path) {
+    try {
+      await stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+
+  async copy(src, dest) {
+    await mkdir(dirname(dest), { recursive: true });
+    await cp(src, dest, { recursive: true });
+  },
+
+  async mkdir(path) {
+    await mkdir(path, { recursive: true });
+  },
+});

package/src/tui/App.tsx

@@ -0,0 +1,87 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text, useApp } from "ink";
+import { ProjectSelector } from "./ProjectSelector.js";
+import { WorktreeSelector } from "./WorktreeSelector.js";
+import type { ProjectEntry } from "../project/registry.js";
+import type { WorktreeInfo } from "../git/worktree.js";
+import type { Messages } from "../i18n/en.js";
+import type { RuntimeAdapter } from "../runtime/adapter.js";
+
+type AppState =
+  | { phase: "project"; projects: ProjectEntry[] }
+  | { phase: "worktree"; project: ProjectEntry; worktrees: WorktreeInfo[] }
+  | { phase: "result"; message: string };
+
+interface AppProps {
+  adapter: RuntimeAdapter;
+  messages: Messages;
+  projects: ProjectEntry[];
+  listWorktrees: (adapter: RuntimeAdapter) => Promise<WorktreeInfo[]>;
+}
+
+export const App: React.FC<AppProps> = ({ adapter, messages, projects, listWorktrees }) => {
+  const { exit } = useApp();
+  const [state, setState] = useState<AppState>({ phase: "project", projects });
+
+  const handleProjectSelect = async (project: ProjectEntry) => {
+    const worktrees = await listWorktrees(adapter);
+    const managedWorktrees = worktrees.filter((wt) => !wt.isMain);
+    setState({ phase: "worktree", project, worktrees: managedWorktrees });
+  };
+
+  const handleWorktreeSelect = (worktree: WorktreeInfo) => {
+    setState({ phase: "result", message: worktree.path });
+  };
+
+  const handleWorktreeCreate = () => {
+    setState({ phase: "result", message: "create" });
+  };
+
+  const handleWorktreeDelete = (_worktree: WorktreeInfo) => {
+    // Deletion flow handled by parent process
+  };
+
+  const handleBack = () => {
+    setState({ phase: "project", projects });
+  };
+
+  // Auto-exit after result is displayed
+  const resultMessage = state.phase === "result" ? state.message : null;
+  useEffect(() => {
+    if (resultMessage) {
+      // Print the selected path for shell wrapper to capture
+      console.log(`__ARBORS_CD__:${resultMessage}`);
+      exit();
+    }
+  }, [resultMessage, exit]);
+
+  if (state.phase === "project") {
+    return (
+      <ProjectSelector
+        projects={state.projects}
+        onSelect={handleProjectSelect}
+        onCancel={() => exit()}
+        messages={messages}
+      />
+    );
+  }
+
+  if (state.phase === "worktree") {
+    return (
+      <WorktreeSelector
+        worktrees={state.worktrees}
+        onSelect={handleWorktreeSelect}
+        onCreate={handleWorktreeCreate}
+        onDelete={handleWorktreeDelete}
+        onCancel={handleBack}
+        messages={messages}
+      />
+    );
+  }
+
+  return (
+    <Box>
+      <Text dimColor>{state.message}</Text>
+    </Box>
+  );
+};

package/src/tui/FuzzyList.tsx

@@ -0,0 +1,111 @@
+import React, { useState, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import Fuse from "fuse.js";
+
+export interface FuzzyListItem {
+  label: string;
+  value: string;
+  meta?: string;
+}
+
+interface FuzzyListProps {
+  items: FuzzyListItem[];
+  onSelect: (item: FuzzyListItem) => void;
+  onCancel: () => void;
+  title: string;
+  helpText: string;
+  maxResults?: number;
+}
+
+const MAX_VISIBLE = 10;
+
+export const FuzzyList: React.FC<FuzzyListProps> = ({
+  items,
+  onSelect,
+  onCancel,
+  title,
+  helpText,
+  maxResults = MAX_VISIBLE,
+}) => {
+  const [query, setQuery] = useState("");
+  const [cursor, setCursor] = useState(0);
+
+  const fuse = useMemo(
+    () => new Fuse(items, { keys: ["label", "value"], threshold: 0.4 }),
+    [items],
+  );
+
+  const filtered = useMemo(() => {
+    if (query === "") return items.slice(0, maxResults);
+    return fuse
+      .search(query)
+      .slice(0, maxResults)
+      .map((r) => r.item);
+  }, [query, items, fuse, maxResults]);
+
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+
+    if (key.return && filtered.length > 0) {
+      onSelect(filtered[cursor]);
+      return;
+    }
+
+    if (key.tab && filtered.length > 0) {
+      setQuery(filtered[0].label);
+      setCursor(0);
+      return;
+    }
+
+    if (key.upArrow) {
+      setCursor((prev) => Math.max(0, prev - 1));
+      return;
+    }
+
+    if (key.downArrow) {
+      setCursor((prev) => Math.min(filtered.length - 1, prev + 1));
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      setQuery((prev) => prev.slice(0, -1));
+      setCursor(0);
+      return;
+    }
+
+    if (input && !key.ctrl && !key.meta) {
+      setQuery((prev) => prev + input);
+      setCursor(0);
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>{title}</Text>
+      <Box>
+        <Text dimColor>{"> "}</Text>
+        <Text>{query}</Text>
+        <Text dimColor>{"█"}</Text>
+      </Box>
+
+      {filtered.length === 0 ? (
+        <Text dimColor> No matches</Text>
+      ) : (
+        filtered.map((item, i) => (
+          <Box key={item.value}>
+            <Text color={i === cursor ? "cyan" : undefined}>{i === cursor ? "→ " : "  "}</Text>
+            <Text bold={i === cursor}>{item.label}</Text>
+            {item.meta ? <Text dimColor>{` (${item.meta})`}</Text> : null}
+          </Box>
+        ))
+      )}
+
+      <Box marginTop={1}>
+        <Text dimColor>{helpText}</Text>
+      </Box>
+    </Box>
+  );
+};

package/src/tui/ProjectSelector.tsx

@@ -0,0 +1,48 @@
+import React from "react";
+import { Text } from "ink";
+import { FuzzyList } from "./FuzzyList.js";
+import type { FuzzyListItem } from "./FuzzyList.js";
+import type { ProjectEntry } from "../project/registry.js";
+import type { Messages } from "../i18n/en.js";
+
+interface ProjectSelectorProps {
+  projects: ProjectEntry[];
+  onSelect: (project: ProjectEntry) => void;
+  onCancel: () => void;
+  messages: Messages;
+}
+
+export const ProjectSelector: React.FC<ProjectSelectorProps> = ({
+  projects,
+  onSelect,
+  onCancel,
+  messages,
+}) => {
+  if (projects.length === 0) {
+    return <Text>{messages.noProjects}</Text>;
+  }
+
+  const items: FuzzyListItem[] = projects.map((p) => ({
+    label: p.name,
+    value: p.path,
+    meta: new Intl.DateTimeFormat(undefined, {
+      dateStyle: "short",
+      timeStyle: "short",
+    }).format(new Date(p.lastAccessed)),
+  }));
+
+  const handleSelect = (item: FuzzyListItem) => {
+    const project = projects.find((p) => p.path === item.value);
+    if (project) onSelect(project);
+  };
+
+  return (
+    <FuzzyList
+      items={items}
+      onSelect={handleSelect}
+      onCancel={onCancel}
+      title={messages.selectProject}
+      helpText={messages.helpFooter}
+    />
+  );
+};

package/src/tui/WorktreeSelector.tsx

@@ -0,0 +1,46 @@
+import React from "react";
+import { Text } from "ink";
+import { FuzzyList } from "./FuzzyList.js";
+import type { FuzzyListItem } from "./FuzzyList.js";
+import type { WorktreeInfo } from "../git/worktree.js";
+import type { Messages } from "../i18n/en.js";
+
+interface WorktreeSelectorProps {
+  worktrees: WorktreeInfo[];
+  onSelect: (worktree: WorktreeInfo) => void;
+  onCreate: () => void;
+  onDelete: (worktree: WorktreeInfo) => void;
+  onCancel: () => void;
+  messages: Messages;
+}
+
+export const WorktreeSelector: React.FC<WorktreeSelectorProps> = ({
+  worktrees,
+  onSelect,
+  onCancel,
+  messages,
+}) => {
+  if (worktrees.length === 0) {
+    return <Text>{messages.noWorktrees}</Text>;
+  }
+
+  const items: FuzzyListItem[] = worktrees.map((wt) => ({
+    label: wt.branch,
+    value: wt.path,
+  }));
+
+  const handleSelect = (item: FuzzyListItem) => {
+    const worktree = worktrees.find((wt) => wt.path === item.value);
+    if (worktree) onSelect(worktree);
+  };
+
+  return (
+    <FuzzyList
+      items={items}
+      onSelect={handleSelect}
+      onCancel={onCancel}
+      title={messages.selectWorktree}
+      helpText={messages.helpWorktree}
+    />
+  );
+};