@bastani/atomic 0.5.3-1 → 0.5.4-0

package/src/sdk/workflows/builtin/ralph/copilot/index.ts

@@ -73,6 +73,12 @@ export default defineWorkflow<"copilot">({
     "Plan → orchestrate → review → debug loop with bounded iteration",
 })
   .run(async (ctx) => {
+    // Free-form workflows receive their positional prompt under
+    // `inputs.prompt`; destructure once so every stage below can close
+    // over a bare `userPromptText` without re-reaching into ctx.inputs.
+    // (Named `userPromptText` rather than `prompt` to avoid confusion
+    // with the `prompt:` object key used in the Copilot send call.)
+    const userPromptText = ctx.inputs.prompt ?? "";
     let consecutiveClean = 0;
     let debuggerReport = "";
 
@@ -86,7 +92,7 @@ export default defineWorkflow<"copilot">({
         async (s) => {
           await s.session.sendAndWait(
             {
-              prompt: buildPlannerPrompt(s.userPrompt, {
+              prompt: buildPlannerPrompt(userPromptText, {
                 iteration,
                 debuggerReport: debuggerReport || undefined,
               }),
@@ -109,7 +115,7 @@ export default defineWorkflow<"copilot">({
         async (s) => {
           await s.session.sendAndWait(
             {
-              prompt: buildOrchestratorPrompt(s.userPrompt, {
+              prompt: buildOrchestratorPrompt(userPromptText, {
                 plannerNotes: planner.result,
               }),
             },
@@ -130,7 +136,7 @@ export default defineWorkflow<"copilot">({
         async (s) => {
           await s.session.sendAndWait(
             {
-              prompt: buildReviewPrompt(s.userPrompt, {
+              prompt: buildReviewPrompt(userPromptText, {
                 gitStatus,
                 iteration,
               }),
@@ -161,7 +167,7 @@ export default defineWorkflow<"copilot">({
           async (s) => {
             await s.session.sendAndWait(
               {
-                prompt: buildReviewPrompt(s.userPrompt, {
+                prompt: buildReviewPrompt(userPromptText, {
                   gitStatus,
                   iteration,
                   isConfirmationPass: true,

package/src/sdk/workflows/builtin/ralph/opencode/index.ts

@@ -42,6 +42,10 @@ export default defineWorkflow<"opencode">({
     "Plan → orchestrate → review → debug loop with bounded iteration",
 })
   .run(async (ctx) => {
+    // Free-form workflows receive their positional prompt under
+    // `inputs.prompt`; destructure once so every stage below can close
+    // over a bare `prompt` string without re-reaching into ctx.inputs.
+    const prompt = ctx.inputs.prompt ?? "";
     let consecutiveClean = 0;
     let debuggerReport = "";
 
@@ -58,7 +62,7 @@ export default defineWorkflow<"opencode">({
             parts: [
               {
                 type: "text",
-                text: buildPlannerPrompt(s.userPrompt, {
+                text: buildPlannerPrompt(prompt, {
                   iteration,
                   debuggerReport: debuggerReport || undefined,
                 }),
@@ -84,7 +88,7 @@ export default defineWorkflow<"opencode">({
             parts: [
               {
                 type: "text",
-                text: buildOrchestratorPrompt(s.userPrompt, {
+                text: buildOrchestratorPrompt(prompt, {
                   plannerNotes: planner.result,
                 }),
               },
@@ -109,7 +113,7 @@ export default defineWorkflow<"opencode">({
             parts: [
               {
                 type: "text",
-                text: buildReviewPrompt(s.userPrompt, {
+                text: buildReviewPrompt(prompt, {
                   gitStatus,
                   iteration,
                 }),
@@ -143,7 +147,7 @@ export default defineWorkflow<"opencode">({
               parts: [
                 {
                   type: "text",
-                  text: buildReviewPrompt(s.userPrompt, {
+                  text: buildReviewPrompt(prompt, {
                     gitStatus,
                     iteration,
                     isConfirmationPass: true,

package/src/sdk/workflows/index.ts

@@ -20,6 +20,8 @@ export type {
   WorkflowContext,
   WorkflowOptions,
   WorkflowDefinition,
+  WorkflowInput,
+  WorkflowInputType,
   StageClientOptions,
   StageSessionOptions,
   ProviderClient,
@@ -52,6 +54,7 @@ export type { OpenCodeValidationWarning } from "../providers/opencode.ts";
 
 // Runtime — tmux utilities
 export {
+  SOCKET_NAME,
   isTmuxInstalled,
   getMuxBinary,
   resetMuxBinaryCache,
@@ -69,6 +72,7 @@ export {
   killWindow,
   sessionExists,
   attachSession,
+  spawnMuxAttach,
   switchClient,
   getCurrentSession,
   attachOrSwitch,
@@ -89,9 +93,13 @@ export {
   AGENTS,
   discoverWorkflows,
   findWorkflow,
+  loadWorkflowsMetadata,
   WORKFLOWS_GITIGNORE,
 } from "../runtime/discovery.ts";
-export type { DiscoveredWorkflow } from "../runtime/discovery.ts";
+export type {
+  DiscoveredWorkflow,
+  WorkflowWithMetadata,
+} from "../runtime/discovery.ts";
 
 // Runtime — workflow loader pipeline
 export { WorkflowLoader } from "../runtime/loader.ts";

package/src/services/system/auto-sync.ts

@@ -90,7 +90,7 @@ export async function autoSyncIfStale(): Promise<void> {
   if (stored === VERSION) return;
 
   console.log(
-    `\n  ${COLORS.dim}Setting up atomic ${COLORS.reset}${COLORS.bold}v${VERSION}${COLORS.reset}${COLORS.dim}…${COLORS.reset}\n`,
+    `\n  ${COLORS.dim}Setting up atomic ${COLORS.reset}${COLORS.bold}v${VERSION}${COLORS.reset}${COLORS.dim}…${COLORS.reset}`,
   );
 
   // Steps are split into two parallel phases:

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

@@ -3,12 +3,12 @@
  *
  * Renders an OpenCode-inspired single-line progress bar:
  *
- *     ⠋ ■■■■■■■■■■■■■■■■■■････････････  50%  tmux / psmux
+ *     ⠋  ■■■■■■■■■■■■■■■■■■････････････  50%  tmux / psmux
  *
- * where the braille spinner is provided by `@clack/prompts` and the bar
- * uses Catppuccin Mocha accent colors (Blue for progress, Green for
- * success, Red for error) with true-color → 256-color → basic ANSI
- * fallback.
+ * 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 so later phases
@@ -23,7 +23,6 @@
  * library, just what auto-sync needs to stop being visually noisy.
  */
 
-import { spinner } from "@clack/prompts";
 import { COLORS } from "@/theme/colors.ts";
 import {
   supportsTrueColor,
@@ -36,9 +35,9 @@ const BAR_EMPTY = "･";
 
 /**
  * Semantic bar states mapped to Catppuccin Mocha colors:
- *   progress → Blue  #89b4fa (accent; "in flight")
- *   success  → Green #a6e3a1 (universal "completed")
- *   error    → Red   #f38ba8 (universal "failed")
+ *   progress → Yellow #f9e2af (warm accent; "in flight")
+ *   success  → Green  #a6e3a1 (universal "completed")
+ *   error    → Red    #f38ba8 (universal "failed")
  *
  * The empty track stays dim regardless — only the filled portion carries
  * the status signal, which keeps the bar legible while still telegraphing
@@ -50,12 +49,12 @@ function fillColor(state: BarState): string {
   if (supportsTrueColor()) {
     switch (state) {
       case "success":
-        return "\x1b[38;2;166;227;161m"; // Catppuccin Green #a6e3a1
+        return "\x1b[38;2;166;227;161m"; // Catppuccin Green  #a6e3a1
       case "error":
-        return "\x1b[38;2;243;139;168m"; // Catppuccin Red   #f38ba8
+        return "\x1b[38;2;243;139;168m"; // Catppuccin Red    #f38ba8
       case "progress":
       default:
-        return "\x1b[38;2;137;180;250m"; // Catppuccin Blue  #89b4fa
+        return "\x1b[38;2;249;226;175m"; // Catppuccin Yellow #f9e2af
     }
   }
   if (supports256Color()) {
@@ -66,7 +65,7 @@ function fillColor(state: BarState): string {
         return "\x1b[38;5;211m";
       case "progress":
       default:
-        return "\x1b[38;5;111m";
+        return "\x1b[38;5;222m";
     }
   }
   switch (state) {
@@ -76,11 +75,36 @@ function fillColor(state: BarState): string {
       return COLORS.red;
     case "progress":
     default:
-      return COLORS.blue;
+      return COLORS.yellow;
   }
 }
 
-/** Render a progress bar: colored filled ■ + dim empty ･ */
+type RGB = [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: [126, 201, 138], end: [166, 227, 161] };
+    case "error":
+      return { start: [224, 108, 136], end: [243, 139, 168] };
+    case "progress":
+    default:
+      return { start: [242, 196, 120], end: [249, 226, 175] };
+  }
+}
+
+/**
+ * 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,
@@ -90,14 +114,25 @@ function renderBar(
   const ratio = Math.max(0, Math.min(1, completed / safeTotal));
   const filled = Math.round(ratio * BAR_WIDTH);
   const empty = BAR_WIDTH - filled;
-  return (
-    fillColor(state) +
-    BAR_FILLED.repeat(filled) +
-    COLORS.reset +
-    COLORS.dim +
-    BAR_EMPTY.repeat(empty) +
-    COLORS.reset
-  );
+
+  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(
@@ -130,6 +165,8 @@ export interface Step {
 /** 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;
@@ -144,18 +181,39 @@ export type Phase = Step[];
 export async function runSteps(phases: Phase[]): Promise<StepResult[]> {
   const total = phases.reduce((n, phase) => n + phase.length, 0);
   const results: StepResult[] = [];
-  const s = spinner();
   let completed = 0;
+  let frameIdx = 0;
+  let currentLabel = phases[0]?.[0]?.label ?? "";
+  let animating = true;
+
+  const isTTY = process.stdout.isTTY ?? false;
 
-  // Start with 0/total so the user sees the bar immediately.
-  s.start(formatLine(0, total, phases[0]?.[0]?.label ?? ""));
+  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) {
-    // Show all in-flight labels for this phase.
     const inFlight = new Set(phase.map((step) => step.label));
-    s.message(formatLine(completed, total, [...inFlight].join(", ")));
+    currentLabel = [...inFlight].join(", ");
 
-    // Run every step in this phase concurrently.
     const phaseResults = await Promise.all(
       phase.map(async (step): Promise<StepResult> => {
         try {
@@ -163,9 +221,7 @@ export async function runSteps(phases: Phase[]): Promise<StepResult[]> {
           completed++;
           inFlight.delete(step.label);
           if (inFlight.size > 0) {
-            s.message(
-              formatLine(completed, total, [...inFlight].join(", ")),
-            );
+            currentLabel = [...inFlight].join(", ");
           }
           return { label: step.label, ok: true };
         } catch (error) {
@@ -174,9 +230,7 @@ export async function runSteps(phases: Phase[]): Promise<StepResult[]> {
           completed++;
           inFlight.delete(step.label);
           if (inFlight.size > 0) {
-            s.message(
-              formatLine(completed, total, [...inFlight].join(", ")),
-            );
+            currentLabel = [...inFlight].join(", ");
           }
           return { label: step.label, ok: false, error: message };
         }
@@ -186,16 +240,32 @@ export async function runSteps(phases: Phase[]): Promise<StepResult[]> {
     results.push(...phaseResults);
   }
 
-  // Stop with a filled bar + final label. Bar color flips to the
-  // universal status colors: green when every step succeeded, red when
-  // any step failed.
+  // 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}`;
-  s.stop(formatLine(total, total, finalLabel, finalState));
+
+  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;
 }

package/src/theme/colors.ts

@@ -1,4 +1,4 @@
-import { supportsColor } from "@/services/system/detect.ts";
+import { supportsColor, supportsTrueColor } from "@/services/system/detect.ts";
 
 /**
  * ANSI color and formatting codes for CLI output
@@ -25,3 +25,67 @@ const NO_COLORS = {
 } 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.
+// Hex values mirror .impeccable.md and src/sdk/runtime/theme.ts.
+// ---------------------------------------------------------------------------
+
+export type PaletteKey = "text" | "dim" | "accent" | "success" | "error" | "warning" | "mauve" | "info";
+
+export const PALETTE: Record<PaletteKey, readonly [number, number, number]> = {
+  text:    [205, 214, 244], // #cdd6f4
+  dim:     [127, 132, 156], // #7f849c (Overlay1)
+  accent:  [137, 180, 250], // #89b4fa (Blue)
+  success: [166, 227, 161], // #a6e3a1 (Green)
+  error:   [243, 139, 168], // #f38ba8 (Red)
+  warning: [249, 226, 175], // #f9e2af (Yellow)
+  mauve:   [203, 166, 247], // #cba6f7 (Mauve)
+  info:    [137, 220, 235], // #89dceb (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;
+}