@bastani/atomic 0.5.0-1 → 0.5.0-2

package/assets/settings.schema.json

@@ -22,11 +22,6 @@
       "format": "date-time",
       "description": "ISO 8601 timestamp of the last configuration update."
     },
-    "prerelease": {
-      "type": "boolean",
-      "description": "When true, 'atomic update' fetches the latest prerelease instead of the latest stable release. Set automatically by the installer when using the --prerelease flag.",
-      "default": false
-    },
     "trustedPaths": {
       "type": "array",
       "description": "Globally trusted workspaces that have completed provider onboarding through 'atomic init'.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/atomic",
-  "version": "0.5.0-1",
+  "version": "0.5.0-2",
   "description": "Configuration management CLI and SDK for coding agents",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,12 @@
   },
   "files": [
     "src",
-    "assets/settings.schema.json"
+    "assets/settings.schema.json",
+    ".claude/agents",
+    ".opencode/agents",
+    ".github/agents",
+    ".github/lsp.json",
+    ".atomic/workflows"
   ],
   "scripts": {
     "dev": "bun run src/cli.ts",

package/src/cli.ts

@@ -147,14 +147,6 @@ Examples:
             process.exit(exitCode);
         });
 
-    program
-        .command("update")
-        .description("Update atomic to the latest version and reinstall skills")
-        .action(async () => {
-            const { updateCommand } = await import("@/commands/cli/update.ts");
-            process.exit(await updateCommand());
-        });
-
     // Add config command for managing CLI settings
     const configCmd = program
         .command("config")
@@ -182,6 +174,22 @@ export const program = createProgram();
  */
 async function main(): Promise<void> {
     try {
+        // Sync tooling deps and global skills on first launch after install
+        // or upgrade. Runs at most once per version bump (gated on a marker
+        // file under ~/.atomic). Skipped for `--version` / `--help` so info
+        // paths stay instant.
+        const argv = process.argv.slice(2);
+        const isInfoCommand =
+            argv.includes("--version") ||
+            argv.includes("-v") ||
+            argv.includes("--help") ||
+            argv.includes("-h");
+
+        if (!isInfoCommand) {
+            const { autoSyncIfStale } = await import("@/services/system/auto-sync.ts");
+            await autoSyncIfStale();
+        }
+
         // Parse and execute the command
         await program.parseAsync();
     } catch (error) {

package/src/commands/cli/workflow.ts

@@ -8,7 +8,7 @@
 
 import { AGENT_CONFIG, type AgentKey } from "@/services/config/index.ts";
 import { COLORS } from "@/theme/colors.ts";
-import { isCommandInstalled } from "@/services/system/detect.ts";
+import { isCommandInstalled, supportsColor, supportsTrueColor } from "@/services/system/detect.ts";
 import { ensureTmuxInstalled, ensureBunInstalled } from "../../lib/spawn.ts";
 import {
   isTmuxInstalled,
@@ -18,7 +18,7 @@ import {
   WorkflowLoader,
   resetMuxBinaryCache,
 } from "@/sdk/workflows.ts";
-import type { AgentType } from "@/sdk/workflows.ts";
+import type { AgentType, DiscoveredWorkflow } from "@/sdk/workflows.ts";
 
 export async function workflowCommand(options: {
   name?: string;
@@ -29,19 +29,7 @@ export async function workflowCommand(options: {
   // List mode
   if (options.list) {
     const workflows = await discoverWorkflows(undefined, options.agent as AgentType | undefined);
-
-    if (workflows.length === 0) {
-      console.log("No workflows found.");
-      console.log("Create a workflow in .atomic/workflows/<name>/<agent>/index.ts");
-      return 0;
-    }
-
-    console.log("Available workflows:\n");
-    for (const wf of workflows) {
-      const badge = wf.source === "local" ? "(local)" : "(global)";
-      console.log(`  ${wf.agent}/${wf.name} ${COLORS.dim}${badge}${COLORS.reset}`);
-      console.log(`    ${COLORS.dim}${wf.path}${COLORS.reset}`);
-    }
+    process.stdout.write(renderWorkflowList(workflows));
     return 0;
   }
 
@@ -162,3 +150,209 @@ export async function workflowCommand(options: {
     return 1;
   }
 }
+
+// ---------------------------------------------------------------------------
+// Workflow list rendering
+//
+// Catppuccin Mocha palette rendered via 24-bit ANSI, with graceful fallback
+// to basic ANSI on legacy terminals and plain text when colour is disabled.
+// Hex values mirror src/sdk/runtime/theme.ts so the CLI output and the TUI
+// speak one visual language.
+// ---------------------------------------------------------------------------
+
+type PaletteKey = "text" | "dim" | "accent" | "success" | "mauve";
+
+const PALETTE: Record<PaletteKey, readonly [number, number, number]> = {
+  text:    [205, 214, 244], // #cdd6f4 — primary text
+  dim:     [127, 132, 156], // #7f849c — secondary text
+  accent:  [137, 180, 250], // #89b4fa — blue accent
+  success: [166, 227, 161], // #a6e3a1 — green (local source)
+  mauve:   [203, 166, 247], // #cba6f7 — mauve (global source)
+};
+
+interface PaintOptions {
+  bold?: boolean;
+}
+
+type Paint = (key: PaletteKey, text: string, opts?: PaintOptions) => string;
+
+/** Stable agent sort order; keeps output deterministic across runs. */
+const AGENT_ORDER: readonly AgentType[] = ["claude", "opencode", "copilot"];
+/** Display names shown as provider sub-headings; honours proper branding. */
+const AGENT_DISPLAY_NAMES: Record<AgentType, string> = {
+  claude: "Claude",
+  opencode: "OpenCode",
+  copilot: "Copilot CLI",
+};
+/** Local first — project-scoped workflows are the most immediately relevant. */
+const SOURCE_ORDER: readonly DiscoveredWorkflow["source"][] = ["local", "global"];
+/** Friendly directory labels shown inline with each section heading. */
+const SOURCE_DIRS: Record<DiscoveredWorkflow["source"], string> = {
+  local: ".atomic/workflows",
+  global: "~/.atomic/workflows",
+};
+/** Section heading colour per source — preserves the source-type semantic. */
+const SOURCE_COLORS: Record<DiscoveredWorkflow["source"], PaletteKey> = {
+  local: "success",
+  global: "mauve",
+};
+
+/**
+ * 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.
+ */
+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",
+      mauve:   "\x1b[35m",
+    };
+    return (key, text, opts) => {
+      const weight = opts?.bold ? "\x1b[1m" : "";
+      return `${weight}${ANSI[key]}${text}\x1b[0m`;
+    };
+  }
+  return (_key, text) => text;
+}
+
+/**
+ * Render `atomic workflow --list` output as a printable string.
+ *
+ * Three-level hierarchy: source → provider → workflow name.
+ *
+ * Layout:
+ *   N workflows
+ *
+ *
+ *   local (.atomic/workflows)
+ *
+ *     Claude
+ *
+ *       <name>
+ *       <name>
+ *
+ *     OpenCode
+ *
+ *       <name>
+ *
+ *
+ *   global (~/.atomic/workflows)
+ *
+ *     Claude
+ *
+ *       <name>
+ *
+ *
+ *   run: atomic workflow -n <name> -a <agent>
+ */
+function renderWorkflowList(workflows: DiscoveredWorkflow[]): string {
+  const paint = createPainter();
+  const lines: string[] = [];
+
+  // Empty state — teach the user where workflows live.
+  if (workflows.length === 0) {
+    lines.push("");
+    lines.push("  " + paint("text", "no workflows found", { bold: true }));
+    lines.push("");
+    lines.push("  " + paint("dim", "create one at"));
+    lines.push(
+      "    " +
+        paint("accent", ".atomic/workflows/<name>/<agent>/index.ts"),
+    );
+    lines.push("");
+    return lines.join("\n") + "\n";
+  }
+
+  // Group by source → agent → sorted names. This gives the renderer O(1)
+  // lookups at both nesting levels and keeps the output deterministic.
+  type ByAgent = Map<AgentType, string[]>;
+  const bySource = new Map<DiscoveredWorkflow["source"], ByAgent>();
+  for (const wf of workflows) {
+    let byAgent = bySource.get(wf.source);
+    if (!byAgent) {
+      byAgent = new Map();
+      bySource.set(wf.source, byAgent);
+    }
+    const names = byAgent.get(wf.agent) ?? [];
+    names.push(wf.name);
+    byAgent.set(wf.agent, names);
+  }
+  for (const byAgent of bySource.values()) {
+    for (const names of byAgent.values()) {
+      names.sort((a, b) => a.localeCompare(b));
+    }
+  }
+
+  // Top header — data-first: the count is bold (it's the actual info), the
+  // noun trails in dim. Handles singular "1 workflow" gracefully.
+  const count = workflows.length;
+  const noun = count === 1 ? "workflow" : "workflows";
+  lines.push("");
+  lines.push(
+    "  " + paint("text", String(count), { bold: true }) + " " + paint("dim", noun),
+  );
+
+  // One stanza per source section, with nested provider sub-groups inside.
+  // Rhythm:
+  //   2 blanks before each source heading  (major break)
+  //   1 blank before each provider heading (tight, they're nested)
+  //   1 blank before each provider's entries
+  for (const source of SOURCE_ORDER) {
+    const byAgent = bySource.get(source);
+    if (!byAgent || byAgent.size === 0) continue;
+
+    // Major break before the source section.
+    lines.push("");
+    lines.push("");
+
+    // Source heading: bold semantic colour + dim inline directory hint.
+    // `local (.atomic/workflows)` — label carries the weight, parens recede.
+    lines.push(
+      "  " +
+        paint(SOURCE_COLORS[source], source, { bold: true }) +
+        paint("dim", ` (${SOURCE_DIRS[source]})`),
+    );
+
+    for (const agent of AGENT_ORDER) {
+      const names = byAgent.get(agent);
+      if (!names || names.length === 0) continue;
+
+      // Provider heading: bold accent blue — a clearly different layer from
+      // both the semantic source heading above and the neutral entries below.
+      lines.push("");
+      lines.push(
+        "    " + paint("accent", AGENT_DISPLAY_NAMES[agent], { bold: true }),
+      );
+      lines.push("");
+
+      for (const name of names) {
+        lines.push("      " + paint("text", name));
+      }
+    }
+  }
+
+  // Footer — dim run hint, separated by the same major-break rhythm.
+  lines.push("");
+  lines.push("");
+  lines.push(
+    "  " + paint("dim", "run: atomic workflow -n <name> -a <agent>"),
+  );
+  lines.push("");
+
+  return lines.join("\n") + "\n";
+}

package/src/lib/spawn.ts

@@ -79,6 +79,22 @@ export function getHomeDir(): string | undefined {
   return process.env.HOME ?? process.env.USERPROFILE;
 }
 
+/**
+ * Options for the user-facing ensure* installers.
+ *
+ * `quiet: true` captures subprocess output instead of streaming it to the
+ * terminal, so a higher-level spinner UI (see auto-sync's `runSteps`) can
+ * own the display. Failures collected in the captured buffer are thrown
+ * out of the ensure* function so the spinner can mark the step red and
+ * surface the captured tail in its summary.
+ *
+ * Default (`quiet: false`) preserves the historical inherit-stdout
+ * behavior used by the ad-hoc fallbacks in chat.ts / workflow.ts.
+ */
+export interface EnsureOptions {
+  quiet?: boolean;
+}
+
 /**
  * Ensure npm is installed, attempting to install Node.js via available system
  * package managers when missing.
@@ -87,7 +103,8 @@ export function getHomeDir(): string | undefined {
  */
 
 
-async function installNodeViaFnm(): Promise<boolean> {
+async function installNodeViaFnm(quiet: boolean): Promise<boolean> {
+  const inherit = !quiet;
   // Install fnm if not present.
   if (!Bun.which("fnm")) {
     let installed = false;
@@ -95,7 +112,7 @@ async function installNodeViaFnm(): Promise<boolean> {
     if (process.platform === "darwin" && Bun.which("brew")) {
       const brew = await runCommand(
         [Bun.which("brew")!, "install", "fnm"],
-        { inherit: true },
+        { inherit },
       );
       installed = brew.success;
     }
@@ -103,7 +120,7 @@ async function installNodeViaFnm(): Promise<boolean> {
     if (!installed && process.platform === "win32" && Bun.which("winget")) {
       const winget = await runCommand(
         [Bun.which("winget")!, "install", "Schniz.fnm"],
-        { inherit: true },
+        { inherit },
       );
       if (winget.success) {
         // Refresh PATH — winget installs to a location on the user PATH.
@@ -121,7 +138,7 @@ async function installNodeViaFnm(): Promise<boolean> {
 
       const curl = await runCommand(
         [shell, "-lc", "curl -fsSL https://fnm.vercel.app/install | bash -s -- --skip-shell"],
-        { inherit: true },
+        { inherit },
       );
       if (!curl.success) return false;
 
@@ -140,7 +157,7 @@ async function installNodeViaFnm(): Promise<boolean> {
   // Install LTS Node.js via fnm.
   const fnmInstall = await runCommand(
     [fnmPath, "install", "--lts"],
-    { inherit: true },
+    { inherit },
   );
   if (!fnmInstall.success) return false;
 
@@ -172,40 +189,67 @@ async function installNodeViaFnm(): Promise<boolean> {
   return !!Bun.which("node");
 }
 
-export async function ensureNpmInstalled(): Promise<void> {
+export async function ensureNpmInstalled(options: EnsureOptions = {}): Promise<void> {
+  const quiet = options.quiet ?? false;
+  const inherit = !quiet;
+
   if (Bun.which("npm")) {
     return;
   }
 
+  // Buffer captured failure output so a thrown error can surface the tail
+  // through the spinner summary. Only populated when `quiet` is set.
+  let capturedDetails = "";
+  const record = (result: SpawnResult) => {
+    if (quiet && !result.success && result.details) {
+      capturedDetails = result.details;
+    }
+  };
+
   // Preferred: install via fnm (no root required, works on all platforms).
-  if (await installNodeViaFnm()) {
+  if (await installNodeViaFnm(quiet)) {
     return;
   }
 
   if (process.platform === "win32") {
     // Fallback: direct Node.js installation via Windows package managers.
     if (Bun.which("winget")) {
-      await runCommand([
-        "winget",
-        "install",
-        "--id",
-        "OpenJS.NodeJS.LTS",
-        "-e",
-        "--silent",
-        "--accept-source-agreements",
-        "--accept-package-agreements",
-      ], { inherit: true });
+      record(
+        await runCommand(
+          [
+            "winget",
+            "install",
+            "--id",
+            "OpenJS.NodeJS.LTS",
+            "-e",
+            "--silent",
+            "--accept-source-agreements",
+            "--accept-package-agreements",
+          ],
+          { inherit },
+        ),
+      );
     } else if (Bun.which("choco")) {
-      await runCommand(["choco", "install", "nodejs-lts", "-y", "--no-progress"], { inherit: true });
+      record(
+        await runCommand(
+          ["choco", "install", "nodejs-lts", "-y", "--no-progress"],
+          { inherit },
+        ),
+      );
     } else if (Bun.which("scoop")) {
-      await runCommand(["scoop", "install", "nodejs-lts"], { inherit: true });
+      record(
+        await runCommand(["scoop", "install", "nodejs-lts"], { inherit }),
+      );
     }
 
     const programFiles = process.env.ProgramFiles;
     if (programFiles) {
       prependPath(join(programFiles, "nodejs"));
     }
-    return;
+    if (Bun.which("npm")) return;
+    throw new Error(
+      capturedDetails || "Could not install Node.js on Windows (no supported package manager found).",
+    );
   }
 
   const shell = Bun.which("bash") ?? Bun.which("sh");
@@ -228,11 +272,15 @@ export async function ensureNpmInstalled(): Promise<void> {
     if (Bun.which("npm")) {
       return;
     }
-    await runCommand([shell, "-lc", script], { inherit: true });
+    record(await runCommand([shell, "-lc", script], { inherit }));
     if (Bun.which("npm")) {
       return;
     }
   }
+
+  throw new Error(
+    capturedDetails || "Could not install Node.js — no supported package manager succeeded.",
+  );
 }
 
 /**
@@ -282,56 +330,79 @@ export async function upgradeLiteparse(): Promise<void> {
 /**
  * Ensure a terminal multiplexer (tmux on Unix, psmux on Windows) is installed.
  * No-op when already present on PATH.
+ *
+ * When `quiet: true`, subprocess output is captured instead of inherited
+ * so an outer spinner UI owns the display. On failure the captured tail
+ * is re-thrown as the error message.
  */
-export async function ensureTmuxInstalled(): Promise<void> {
+export async function ensureTmuxInstalled(options: EnsureOptions = {}): Promise<void> {
+  const quiet = options.quiet ?? false;
+  const inherit = !quiet;
+
   // Check for any multiplexer binary
   if (Bun.which("tmux") || Bun.which("psmux") || Bun.which("pmux")) return;
 
+  let capturedDetails = "";
+  const record = (result: SpawnResult) => {
+    if (quiet && !result.success && result.details) {
+      capturedDetails = result.details;
+    }
+  };
+
   if (process.platform === "win32") {
     // Windows: install psmux
     const winget = Bun.which("winget");
     if (winget) {
-      const result = await runCommand([winget, "install", "psmux", "--accept-source-agreements", "--accept-package-agreements"], { inherit: true });
+      const result = await runCommand([winget, "install", "psmux", "--accept-source-agreements", "--accept-package-agreements"], { inherit });
+      record(result);
       if (result.success && (Bun.which("psmux") || Bun.which("tmux"))) return;
     }
 
     const scoop = Bun.which("scoop");
     if (scoop) {
-      await runCommand([scoop, "bucket", "add", "psmux", "https://github.com/psmux/scoop-psmux"], { inherit: true });
-      const result = await runCommand([scoop, "install", "psmux"], { inherit: true });
+      await runCommand([scoop, "bucket", "add", "psmux", "https://github.com/psmux/scoop-psmux"], { inherit });
+      const result = await runCommand([scoop, "install", "psmux"], { inherit });
+      record(result);
       if (result.success && (Bun.which("psmux") || Bun.which("tmux"))) return;
     }
 
     const choco = Bun.which("choco");
     if (choco) {
-      const result = await runCommand([choco, "install", "psmux", "-y", "--no-progress"], { inherit: true });
+      const result = await runCommand([choco, "install", "psmux", "-y", "--no-progress"], { inherit });
+      record(result);
       if (result.success && (Bun.which("psmux") || Bun.which("tmux"))) return;
     }
 
     const cargo = Bun.which("cargo");
     if (cargo) {
-      const result = await runCommand([cargo, "install", "psmux"], { inherit: true });
+      const result = await runCommand([cargo, "install", "psmux"], { inherit });
+      record(result);
       if (result.success) {
         const home = getHomeDir();
         if (home) prependPath(join(home, ".cargo", "bin"));
         if (Bun.which("psmux") || Bun.which("tmux")) return;
       }
     }
-    return;
+    throw new Error(
+      capturedDetails || "Could not install psmux — no supported Windows package manager succeeded.",
+    );
   }
 
   // Unix / macOS
   if (process.platform === "darwin") {
     const brew = Bun.which("brew");
     if (brew) {
-      const result = await runCommand([brew, "install", "tmux"], { inherit: true });
+      const result = await runCommand([brew, "install", "tmux"], { inherit });
+      record(result);
       if (result.success && Bun.which("tmux")) return;
     }
   }
 
   // Linux package managers
   const shell = Bun.which("bash") ?? Bun.which("sh");
-  if (!shell) return;
+  if (!shell) {
+    throw new Error("Neither bash nor sh is available to install tmux.");
+  }
 
   const managers: string[] = [
     "command -v apt-get >/dev/null 2>&1 && sudo apt-get update -qq && sudo apt-get install -y tmux",
@@ -343,9 +414,13 @@ export async function ensureTmuxInstalled(): Promise<void> {
   ];
 
   for (const script of managers) {
-    await runCommand([shell, "-lc", script], { inherit: true });
+    record(await runCommand([shell, "-lc", script], { inherit }));
     if (Bun.which("tmux")) return;
   }
+
+  throw new Error(
+    capturedDetails || "Could not install tmux — no supported package manager succeeded.",
+  );
 }
 
 /**

package/src/sdk/runtime/loader.ts

@@ -25,7 +25,7 @@ import { validateClaudeWorkflow } from "../providers/claude.ts";
 // Absolute path to the currently-running atomic CLI's own SDK source tree
 // (i.e. `<install_root>/src/sdk`). Computed from this file's URL so it always
 // points at the actual installed atomic, regardless of how it was launched
-// (dev checkout, global `bun install -g atomic`, `bunx atomic`, etc).
+// (dev checkout, global `bun install -g @bastani/atomic`, `bunx atomic`, etc).
 const ATOMIC_SDK_DIR = Bun.fileURLToPath(new URL("..", import.meta.url));
 
 // Directory of this loader file. Used as the parent for `Bun.resolveSync`

package/src/services/config/config-path.ts

@@ -3,7 +3,7 @@
  *
  * Two installation modes:
  * 1. Source/Development: Running from source with `bun run src/cli.ts`
- * 2. npm/bun installed: Installed via `bun add -g atomic`
+ * 2. npm/bun installed: Installed via `bun add -g @bastani/atomic`
  */
 
 import { join } from "path";

package/src/services/config/settings.ts

@@ -26,7 +26,6 @@ interface AtomicSettings {
   scm?: "github" | "sapling";
   version?: number;
   lastUpdated?: string;
-  prerelease?: boolean;
   trustedPaths?: TrustedPathEntry[];
 }
 
@@ -97,14 +96,6 @@ function normalizeTrustedPaths(entries: TrustedPathEntry[] | undefined): Trusted
   return Array.from(deduped.values());
 }
 
-/**
- * Get the prerelease channel preference.
- * Only checks global settings (~/.atomic/settings.json) since this is an install-level setting.
- */
-export function getPrereleasePreference(): boolean {
-  return loadSettingsFileSync(globalSettingsPath()).prerelease === true;
-}
-
 export async function isTrustedWorkspacePath(
   workspacePath: string,
   provider: AgentKey,