@bastani/atomic 0.6.8 → 0.7.0-1

package/src/services/system/install-ui.ts

@@ -1,296 +0,0 @@
-/**
- * Progress UI primitives for the first-run install flow (auto-sync).
- *
- * Renders an OpenCode-inspired single-line progress bar:
- *
- *     ⠋  ■■■■■■■■■■■■■■■■■■････････････  50%  tmux / psmux
- *
- * The braille spinner animates in-place via a setInterval loop and the
- * bar uses Catppuccin Mocha accent colors (Yellow for progress, Green
- * for success, Red for error) with a per-character true-color gradient
- * that falls back gracefully through 256-color → basic ANSI.
- *
- * Steps are grouped into **phases**. Steps within a phase run in parallel
- * (via `Promise.all`); phases themselves run sequentially. The progress
- * bar advances and the label updates in real-time as individual steps
- * complete within a phase.
- *
- * A final summary (✓/✗ per step) is printed after all steps finish, and
- * any captured stderr/stdout from a failed step is shown beneath it.
- *
- * Kept intentionally small — this is not a general-purpose progress
- * library, just what auto-sync needs to stop being visually noisy.
- */
-
-import { COLORS, PALETTE, paletteRgb, type PaletteKey } from "../../theme/colors.ts";
-import {
-  supportsTrueColor,
-  supports256Color,
-} from "./detect.ts";
-
-const BAR_WIDTH = 30;
-const BAR_FILLED = "■";
-const BAR_EMPTY = "･";
-
-/**
- * Semantic bar states mapped to Catppuccin Mocha colors:
- *   progress → Yellow (warm accent; "in flight")
- *   success  → Green  (universal "completed")
- *   error    → Red    (universal "failed")
- *
- * The empty track stays dim regardless — only the filled portion carries
- * the status signal, which keeps the bar legible while still telegraphing
- * the outcome at a glance.
- */
-type BarState = "progress" | "success" | "error";
-
-const BAR_STATE_PALETTE: Record<BarState, PaletteKey> = {
-  progress: "warning",
-  success: "success",
-  error: "error",
-};
-
-function fillColor(state: BarState): string {
-  if (supportsTrueColor()) {
-    const [r, g, b] = PALETTE[BAR_STATE_PALETTE[state]];
-    return `\x1b[38;2;${r};${g};${b}m`;
-  }
-  if (supports256Color()) {
-    switch (state) {
-      case "success":
-        return "\x1b[38;5;150m";
-      case "error":
-        return "\x1b[38;5;211m";
-      case "progress":
-      default:
-        return "\x1b[38;5;222m";
-    }
-  }
-  switch (state) {
-    case "success":
-      return COLORS.green;
-    case "error":
-      return COLORS.red;
-    case "progress":
-    default:
-      return COLORS.yellow;
-  }
-}
-
-type RGB = readonly [number, number, number];
-
-/**
- * Gradient endpoints for the filled bar segment. Each state interpolates
- * from a slightly deeper/warmer tone (left) to the full Catppuccin
- * accent (right), producing a smooth continuous color gradient.
- */
-function gradientEndpoints(state: BarState): { start: RGB; end: RGB } {
-  switch (state) {
-    case "success":
-      return { start: paletteRgb("teal"), end: paletteRgb("green") };
-    case "error":
-      return { start: paletteRgb("maroon"), end: paletteRgb("red") };
-    case "progress":
-    default:
-      return { start: paletteRgb("peach"), end: paletteRgb("yellow") };
-  }
-}
-
-/**
- * Render a progress bar: gradient-filled ■ + dim empty ･
- *
- * In true-color mode each filled character gets its own interpolated RGB
- * value, producing a smooth continuous gradient. Falls back to a single
- * solid color on 256-color or basic ANSI terminals.
- */
-function renderBar(
-  completed: number,
-  total: number,
-  state: BarState,
-): string {
-  const safeTotal = Math.max(1, total);
-  const ratio = Math.max(0, Math.min(1, completed / safeTotal));
-  const filled = Math.round(ratio * BAR_WIDTH);
-  const empty = BAR_WIDTH - filled;
-
-  let filledStr = "";
-  if (filled > 0) {
-    if (supportsTrueColor()) {
-      const { start, end } = gradientEndpoints(state);
-      for (let i = 0; i < filled; i++) {
-        const t = filled > 1 ? i / (filled - 1) : 1;
-        const r = Math.round(start[0] + (end[0] - start[0]) * t);
-        const g = Math.round(start[1] + (end[1] - start[1]) * t);
-        const b = Math.round(start[2] + (end[2] - start[2]) * t);
-        filledStr += `\x1b[38;2;${r};${g};${b}m${BAR_FILLED}`;
-      }
-      filledStr += COLORS.reset;
-    } else {
-      filledStr = fillColor(state) + BAR_FILLED.repeat(filled) + COLORS.reset;
-    }
-  }
-
-  return filledStr + COLORS.dim + BAR_EMPTY.repeat(empty) + COLORS.reset;
-}
-
-function formatLine(
-  completed: number,
-  total: number,
-  label: string,
-  state: BarState = "progress",
-): string {
-  const bar = renderBar(completed, total, state);
-  const safeTotal = Math.max(1, total);
-  const pct = Math.round(
-    Math.max(0, Math.min(1, completed / safeTotal)) * 100,
-  );
-  const percent = `${COLORS.dim}${String(pct).padStart(3)}%${COLORS.reset}`;
-  return `${bar}  ${percent}  ${label}`;
-}
-
-export interface StepResult {
-  label: string;
-  ok: boolean;
-  /** Error message (if any) surfaced in the final summary. */
-  error?: string;
-}
-
-export interface Step {
-  label: string;
-  fn: () => Promise<unknown>;
-}
-
-/** A phase is a group of steps that run in parallel. */
-export type Phase = Step[];
-
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-/**
- * Runs phases of async steps with a single persistent spinner line
- * showing stepped progress. Steps within each phase run in parallel;
- * phases run sequentially so later phases can depend on earlier ones.
- *
- * Each step's failure is collected rather than thrown, mirroring
- * auto-sync's "best-effort" contract.
- *
- * Returns the per-step results in phase/submission order so the caller
- * can render a summary.
- */
-export async function runSteps(phases: Phase[]): Promise<StepResult[]> {
-  const total = phases.reduce((n, phase) => n + phase.length, 0);
-  const results: StepResult[] = [];
-  let completed = 0;
-  let frameIdx = 0;
-  let currentLabel = phases[0]?.[0]?.label ?? "";
-  let animating = true;
-
-  const isTTY = process.stdout.isTTY ?? false;
-
-  if (isTTY) process.stdout.write("\x1b[?25l"); // hide cursor
-
-  // Restore cursor on unexpected exit so the terminal isn't left broken.
-  const restoreCursor = () => {
-    if (isTTY) process.stdout.write("\x1b[?25h");
-  };
-  process.once("SIGINT", restoreCursor);
-  process.once("SIGTERM", restoreCursor);
-
-  // Animate the braille spinner + progress bar in-place (80 ms/frame).
-  const interval = isTTY
-    ? setInterval(() => {
-        if (!animating) return;
-        const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
-        const line = formatLine(completed, total, currentLabel);
-        process.stdout.write(
-          `\r\x1b[2K  ${COLORS.blue}${frame}${COLORS.reset}  ${line}`,
-        );
-        frameIdx++;
-      }, 80)
-    : null;
-
-  for (const phase of phases) {
-    const inFlight = new Set(phase.map((step) => step.label));
-    currentLabel = [...inFlight].join(", ");
-
-    const phaseResults = await Promise.all(
-      phase.map(async (step): Promise<StepResult> => {
-        try {
-          await step.fn();
-          completed++;
-          inFlight.delete(step.label);
-          if (inFlight.size > 0) {
-            currentLabel = [...inFlight].join(", ");
-          }
-          return { label: step.label, ok: true };
-        } catch (error) {
-          const message =
-            error instanceof Error ? error.message : String(error);
-          completed++;
-          inFlight.delete(step.label);
-          if (inFlight.size > 0) {
-            currentLabel = [...inFlight].join(", ");
-          }
-          return { label: step.label, ok: false, error: message };
-        }
-      }),
-    );
-
-    results.push(...phaseResults);
-  }
-
-  // Stop animation and render the final line.
-  animating = false;
-  if (interval) clearInterval(interval);
-  process.removeListener("SIGINT", restoreCursor);
-  process.removeListener("SIGTERM", restoreCursor);
-
-  const okCount = results.filter((r) => r.ok).length;
-  const allOk = okCount === total;
-  const finalState: BarState = allOk ? "success" : "error";
-  const glyph = allOk
-    ? `${fillColor("success")}✓${COLORS.reset}`
-    : `${fillColor("error")}✗${COLORS.reset}`;
-  const finalLabel = allOk
-    ? `${fillColor("success")}Setup complete${COLORS.reset}`
-    : `${fillColor("error")}Setup finished with errors${COLORS.reset}`;
-
-  if (isTTY) {
-    process.stdout.write(
-      `\r\x1b[2K  ${glyph}  ${formatLine(total, total, finalLabel, finalState)}\n`,
-    );
-    process.stdout.write("\x1b[?25h"); // show cursor
-  } else {
-    console.log(
-      `  ${glyph}  ${formatLine(total, total, finalLabel, finalState)}`,
-    );
-  }
-
-  return results;
-}
-
-/**
- * Print a compact per-step summary after `runSteps`. Successes render as
- * a single dim line; failures render with a red cross and an indented
- * excerpt of the captured error.
- */
-export function printSummary(results: StepResult[]): void {
-  for (const result of results) {
-    if (result.ok) {
-      console.log(
-        `  ${COLORS.green}✓${COLORS.reset} ${COLORS.dim}${result.label}${COLORS.reset}`,
-      );
-    } else {
-      console.log(
-        `  ${COLORS.red}✗${COLORS.reset} ${result.label}`,
-      );
-      if (result.error) {
-        // Indent the first ~4 lines of the error so it reads as a nested
-        // block rather than wall-of-text.
-        const lines = result.error.split("\n").slice(0, 4);
-        for (const line of lines) {
-          console.log(`    ${COLORS.dim}${line}${COLORS.reset}`);
-        }
-      }
-    }
-  }
-}

package/src/services/system/skills.ts

@@ -1,58 +0,0 @@
-/**
- * Global skills installation.
- *
- * Copies bundled agent skills from the installed package into the
- * provider-native global skill roots, mirroring the merge-copy approach
- * used by {@link installGlobalAgents} for agent configs.
- */
-
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { createCommonIgnoreFilter } from "../../lib/common-ignore.ts";
-import { copyDir, pathExists } from "./copy.ts";
-
-/**
- * Locate the package root by walking up from this module. Both in installed
- * (`<pkg>/src/services/system/skills.ts`) and dev checkout layouts the
- * package root is three directories up.
- */
-function packageRoot(): string {
-  return join(import.meta.dir, "..", "..", "..");
-}
-
-/** Honors ATOMIC_SETTINGS_HOME so tests can point at a temp dir. */
-function homeRoot(): string {
-  return process.env.ATOMIC_SETTINGS_HOME ?? homedir();
-}
-
-/**
- * Global skill directories keyed by provider.
- *
- * From CLAUDE.md:
- *   - `~/.agents/skills` for OpenCode and Copilot CLI
- *   - `~/.claude/skills` for Claude Code
- */
-const SKILL_DEST_DIRS = [
-  ".agents/skills",
-  ".claude/skills",
-] as const;
-
-/**
- * Copy bundled skills to the global skill directories.
- */
-export async function installGlobalSkills(): Promise<void> {
-  const src = join(packageRoot(), ".agents", "skills");
-
-  if (!(await pathExists(src))) {
-    throw new Error(`Bundled skills missing at ${src}`);
-  }
-
-  const home = homeRoot();
-  const ignoreFilter = createCommonIgnoreFilter();
-
-  await Promise.all(
-    SKILL_DEST_DIRS.map((rel) =>
-      copyDir(src, join(home, rel), { ignoreFilter }),
-    ),
-  );
-}

package/src/theme/colors.ts

@@ -1,96 +0,0 @@
-import { supportsColor, supportsTrueColor } from "../services/system/detect.ts";
-import { flavors, type ColorName } from "@catppuccin/palette";
-
-/**
- * ANSI color and formatting codes for CLI output
- * Respects the NO_COLOR environment variable
- */
-const ANSI_CODES = {
-  bold: "\x1b[1m",
-  dim: "\x1b[2m",
-  reset: "\x1b[0m",
-  red: "\x1b[31m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  blue: "\x1b[34m",
-} as const;
-
-const NO_COLORS = {
-  bold: "",
-  dim: "",
-  reset: "",
-  red: "",
-  green: "",
-  yellow: "",
-  blue: "",
-} as const;
-
-export const COLORS = supportsColor() ? ANSI_CODES : NO_COLORS;
-
-// ---------------------------------------------------------------------------
-// Catppuccin Mocha palette — shared across all CLI commands
-//
-// Truecolor terminals get the full palette via 24-bit ANSI SGR; legacy
-// terminals degrade to basic ANSI; NO_COLOR emits plain text.
-// ---------------------------------------------------------------------------
-
-export type PaletteKey = "text" | "dim" | "accent" | "success" | "error" | "warning" | "mauve" | "info";
-
-export function paletteRgb(name: ColorName): readonly [number, number, number] {
-  const { r, g, b } = flavors.mocha.colors[name].rgb;
-  return [r, g, b];
-}
-
-export const PALETTE: Record<PaletteKey, readonly [number, number, number]> = {
-  text:    paletteRgb("text"),
-  dim:     paletteRgb("overlay1"),
-  accent:  paletteRgb("blue"),
-  success: paletteRgb("green"),
-  error:   paletteRgb("red"),
-  warning: paletteRgb("yellow"),
-  mauve:   paletteRgb("mauve"),
-  info:    paletteRgb("sky"),
-};
-
-export interface PaintOptions {
-  bold?: boolean;
-}
-
-export type Paint = (key: PaletteKey, text: string, opts?: PaintOptions) => string;
-
-/**
- * Build a colour-aware painter for the current terminal.
- *
- * Truecolor terminals get the full Catppuccin palette; legacy terminals
- * degrade to basic ANSI; NO_COLOR emits plain text. The optional `bold`
- * flag adds weight contrast — essential for typographic hierarchy in a
- * monospace medium where size and family are fixed.
- */
-export function createPainter(): Paint {
-  if (supportsTrueColor()) {
-    return (key, text, opts) => {
-      const [r, g, b] = PALETTE[key];
-      const sgr = opts?.bold
-        ? `\x1b[1;38;2;${r};${g};${b}m`
-        : `\x1b[38;2;${r};${g};${b}m`;
-      return `${sgr}${text}\x1b[0m`;
-    };
-  }
-  if (supportsColor()) {
-    const ANSI: Record<PaletteKey, string> = {
-      text:    "",
-      dim:     "\x1b[2m",
-      accent:  "\x1b[34m",
-      success: "\x1b[32m",
-      error:   "\x1b[31m",
-      warning: "\x1b[33m",
-      mauve:   "\x1b[35m",
-      info:    "\x1b[36m",
-    };
-    return (key, text, opts) => {
-      const weight = opts?.bold ? "\x1b[1m" : "";
-      return `${weight}${ANSI[key]}${text}\x1b[0m`;
-    };
-  }
-  return (_key, text) => text;
-}

package/src/theme/logo.ts

@@ -1,123 +0,0 @@
-/**
- * Atomic ASCII-art logo and Catppuccin gradient colorization.
- *
- * Shared between the init banner and the post-install completion screen.
- */
-
-import {
-  supportsTrueColor,
-  supports256Color,
-  supportsColor,
-} from "../services/system/detect.ts";
-import { flavors, type CatppuccinFlavor, type ColorName } from "@catppuccin/palette";
-
-export const ATOMIC_BLOCK_LOGO = [
-  "█▀▀█ ▀▀█▀▀ █▀▀█ █▀▄▀█ ▀█▀ █▀▀",
-  "█▄▄█   █   █  █ █ ▀ █  █  █  ",
-  "▀  ▀   ▀   ▀▀▀▀ ▀   ▀ ▀▀▀ ▀▀▀",
-];
-
-const GRADIENT_COLOR_NAMES = [
-  "rosewater",
-  "flamingo",
-  "pink",
-  "mauve",
-  "lavender",
-  "blue",
-  "sapphire",
-  "sky",
-  "teal",
-] as const satisfies readonly ColorName[];
-
-function gradientFromFlavor(flavor: CatppuccinFlavor): string[] {
-  return GRADIENT_COLOR_NAMES.map((name) => flavor.colors[name].hex);
-}
-
-/** Catppuccin gradient (dark terminal). */
-export const GRADIENT_DARK = gradientFromFlavor(flavors.mocha);
-
-/** Catppuccin gradient (light terminal). */
-export const GRADIENT_LIGHT = gradientFromFlavor(flavors.latte);
-
-/** 256-color approximation of the gradient. */
-export const GRADIENT_256 = [224, 218, 219, 183, 147, 111, 117, 159, 115];
-
-function hexToRgb(hex: string): [number, number, number] {
-  const h = hex.replace("#", "");
-  return [
-    parseInt(h.substring(0, 2), 16),
-    parseInt(h.substring(2, 4), 16),
-    parseInt(h.substring(4, 6), 16),
-  ];
-}
-
-function interpolateHex(gradient: readonly string[], t: number): [number, number, number] {
-  const pos = Math.max(0, Math.min(1, t)) * (gradient.length - 1);
-  const lo = Math.floor(pos);
-  const hi = Math.min(lo + 1, gradient.length - 1);
-  const frac = pos - lo;
-  const [r1, g1, b1] = hexToRgb(gradient[lo]!);
-  const [r2, g2, b2] = hexToRgb(gradient[hi]!);
-  return [
-    Math.round(r1 + (r2 - r1) * frac),
-    Math.round(g1 + (g2 - g1) * frac),
-    Math.round(b1 + (b2 - b1) * frac),
-  ];
-}
-
-function interpolate256(gradient: number[], t: number): number {
-  const pos = Math.max(0, Math.min(1, t)) * (gradient.length - 1);
-  const lo = Math.floor(pos);
-  return gradient[lo]!;
-}
-
-export function colorizeLineTrueColor(line: string, gradient: readonly string[]): string {
-  let out = "";
-  const len = line.length;
-  for (let i = 0; i < len; i++) {
-    const ch = line[i]!;
-    if (ch === " ") {
-      out += ch;
-      continue;
-    }
-    const [r, g, b] = interpolateHex(gradient, len > 1 ? i / (len - 1) : 0);
-    out += `\x1b[38;2;${r};${g};${b}m${ch}`;
-  }
-  return out + "\x1b[0m";
-}
-
-export function colorizeLine256(line: string, gradient: number[]): string {
-  let out = "";
-  const len = line.length;
-  for (let i = 0; i < len; i++) {
-    const ch = line[i]!;
-    if (ch === " ") {
-      out += ch;
-      continue;
-    }
-    const code = interpolate256(gradient, len > 1 ? i / (len - 1) : 0);
-    out += `\x1b[38;5;${code}m${ch}`;
-  }
-  return out + "\x1b[0m";
-}
-
-/** Print the Atomic block logo with Catppuccin gradient colorization. */
-export function displayBlockBanner(): void {
-  const isDark = !(process.env.COLORFGBG ?? "").startsWith("0;");
-  const truecolor = supportsTrueColor();
-  const color256 = supports256Color();
-  const hasColor = supportsColor();
-
-  console.log();
-  for (const line of ATOMIC_BLOCK_LOGO) {
-    if (truecolor) {
-      const gradient = isDark ? GRADIENT_DARK : GRADIENT_LIGHT;
-      console.log(`  ${colorizeLineTrueColor(line, gradient)}`);
-    } else if (color256 && hasColor) {
-      console.log(`  ${colorizeLine256(line, GRADIENT_256)}`);
-    } else {
-      console.log(`  ${line}`);
-    }
-  }
-  console.log();
-}

package/src/version.ts

@@ -1,7 +0,0 @@
-/**
- * Version - read from package.json
- */
-import packageJson from "../package.json";
-
-export const VERSION = packageJson.version;
-// test marker