@solidxai/core 0.1.13-beta.9 → 0.1.13

package/src/testing/README.md

@@ -479,10 +479,11 @@ Common `test run` flags (all pass through solidctl unchanged):
 - `--ui-navigation-timeout-ms <number>` — default wait for `ui.goto`
 - `--timeout-ms <number>` / `--retries <number>` — scenario-level guard and retry count
 - `--scenario-ids <ids>` / `--include-tags <tags>` / `--skip-scenario-ids <ids>`
+- `--no-progress` — disable the interactive test progress footer
 
 ## Add A New Step (SOP)
 1. Create a new `*.step.ts` in the right domain folder.
 2. Implement a `registerXSteps(registry)` function and `registry.register("op.name", handler)`.
 3. Validate required `step.with` fields and throw clear errors.
 4. Use adapters via `ctx.api` / `ctx.ui` and update `ctx.last` when helpful.
-5. Export and register it from the domain `index.ts`.
+5. Export and register it from the domain `index.ts`.

package/src/testing/reporter/console-reporter.ts

@@ -150,6 +150,10 @@ export class ConsoleReporter implements Reporter {
   private passedScenarios = 0;
   private failedScenarios = 0;
 
+  onRunStart(_args: { total: number }): void {
+    // Progress-aware reporters use this hook; the plain console reporter has no setup.
+  }
+
   onScenarioStart(scenario: { id: string; name?: string }): void {
     const label = scenario.name ? `${scenario.id} (${scenario.name})` : scenario.id;
     console.log(`\n▶ Scenario: ${label}`);

package/src/testing/reporter/progress-reporter.ts

@@ -0,0 +1,251 @@
+import * as readline from "readline";
+import type { StepPhase } from "../contracts/runtime-context.types";
+import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
+import type { SolidTestSpecResult } from "../contracts/test-spec.types";
+import type { Reporter } from "./reporter.types";
+
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+const ANSI_DIM = "\u001b[2m";
+const ANSI_GREEN = "\u001b[32m";
+const ANSI_COLOR_OFF = "\u001b[39m";
+const ANSI_RED = "\u001b[31m";
+const ANSI_INVERSE = "\u001b[7m";
+const ANSI_INVERSE_OFF = "\u001b[27m";
+
+export class ProgressReporter implements Reporter {
+  private startedAt = Date.now();
+  private total = 0;
+  private completed = 0;
+  private passed = 0;
+  private failed = 0;
+  private timer?: NodeJS.Timeout;
+  private rendered = false;
+
+  constructor(private readonly delegate: Reporter) {}
+
+  onRunStart(args: { total: number }): void {
+    this.total = args.total;
+    this.startedAt = Date.now();
+    this.completed = 0;
+    this.passed = 0;
+    this.failed = 0;
+    this.delegate.onRunStart?.(args);
+    this.startTimer();
+    this.renderFooter();
+  }
+
+  onScenarioStart(scenario: ScenarioSpec): void {
+    this.withFooterPaused(() => this.delegate.onScenarioStart(scenario));
+  }
+
+  onScenarioEnd(
+    scenario: ScenarioSpec,
+    result: { ok: boolean; error?: unknown; durationMs: number },
+  ): void {
+    this.completed += 1;
+    if (result.ok) {
+      this.passed += 1;
+    } else {
+      this.failed += 1;
+    }
+    this.withFooterPaused(() => this.delegate.onScenarioEnd(scenario, result));
+  }
+
+  onStepStart(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepStart(args));
+  }
+
+  onStepEnd(args: {
+    scenarioId: string;
+    phase: StepPhase;
+    step: OpStep;
+    ok: boolean;
+    error?: unknown;
+    durationMs: number;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onStepEnd(args));
+  }
+
+  onSpecResult(args: {
+    scenarioId: string;
+    specId: string;
+    stepName?: string;
+    result: SolidTestSpecResult;
+  }): void {
+    this.withFooterPaused(() => this.delegate.onSpecResult?.(args));
+  }
+
+  attach(args: {
+    scenarioId: string;
+    name: string;
+    contentType: string;
+    data: Buffer | string;
+  }): void {
+    this.withFooterPaused(() => this.delegate.attach?.(args));
+  }
+
+  onRunEnd(args: {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+  }): void {
+    this.completed = args.passed + args.failed;
+    this.passed = args.passed;
+    this.failed = args.failed;
+    this.total = args.total;
+    this.stopTimer();
+    this.withFooterPaused(() => this.delegate.onRunEnd?.(args), false);
+  }
+
+  private startTimer(): void {
+    this.stopTimer();
+    if (!this.isInteractive()) {
+      return;
+    }
+    this.timer = setInterval(() => this.renderFooter(), 1_000);
+    this.timer.unref?.();
+  }
+
+  private stopTimer(): void {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = undefined;
+  }
+
+  private withFooterPaused(callback: () => void, renderAfter = true): void {
+    this.clearFooter();
+    callback();
+    if (renderAfter) {
+      this.renderFooter();
+    }
+  }
+
+  private renderFooter(): void {
+    if (!this.isInteractive()) {
+      return;
+    }
+
+    const terminalWidth = process.stdout.columns || 80;
+    const elapsed = formatElapsed(Date.now() - this.startedAt);
+    const progressText = `${this.completed}/${this.total}`;
+    const resultText = `${ANSI_GREEN}${this.passed} passed${ANSI_COLOR_OFF}${ANSI_DIM} | ${ANSI_BOLD_OFF}${this.failed ? ANSI_RED : ANSI_DIM}${this.failed} failed${this.failed ? ANSI_COLOR_OFF : ANSI_BOLD_OFF}`;
+    const footer = [
+      `${ANSI_BOLD}Tests${ANSI_BOLD_OFF}: ${this.renderProgressBar(terminalWidth)} ${progressText}`,
+      `${ANSI_BOLD}Elapsed${ANSI_BOLD_OFF}: ${elapsed}`,
+      resultText,
+    ].join(`${ANSI_DIM} | ${ANSI_BOLD_OFF}`);
+
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    process.stdout.write(truncateAnsiText(`${ANSI_INVERSE} ${footer} ${ANSI_INVERSE_OFF}`, terminalWidth));
+    this.rendered = true;
+  }
+
+  private clearFooter(): void {
+    if (!this.rendered || !this.isInteractive()) {
+      return;
+    }
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    this.rendered = false;
+  }
+
+  private renderProgressBar(terminalWidth: number): string {
+    const width = terminalWidth >= 120 ? 30 : terminalWidth >= 90 ? 22 : 14;
+    const ratio = this.total > 0 ? Math.min(1, this.completed / this.total) : 0;
+    const filled = Math.round(width * ratio);
+    const empty = Math.max(0, width - filled);
+    return `[${ANSI_GREEN}${"=".repeat(filled)}${ANSI_COLOR_OFF}${" ".repeat(empty)}]`;
+  }
+
+  private isInteractive(): boolean {
+    return Boolean(process.stdout.isTTY || process.env.SOLIDCTL_TEST_PROGRESS === "1");
+  }
+}
+
+function formatElapsed(durationMs: number): string {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) {
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}:${remainingMinutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+}
+
+function truncateAnsiText(text: string, maxWidth: number): string {
+  if (maxWidth <= 0) {
+    return "";
+  }
+
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+  let hasEscape = false;
+
+  while (index < text.length) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      hasEscape = true;
+      index += match[0].length;
+      continue;
+    }
+
+    if (visibleWidth >= maxWidth) {
+      break;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  if (index < text.length && maxWidth >= 1) {
+    output = trimAnsiText(output, maxWidth - 1) + "…";
+  }
+
+  if (hasEscape && !output.endsWith(ANSI_INVERSE_OFF)) {
+    output += ANSI_INVERSE_OFF;
+  }
+
+  return output;
+}
+
+function trimAnsiText(text: string, maxWidth: number): string {
+  let visibleWidth = 0;
+  let index = 0;
+  let output = "";
+
+  while (index < text.length && visibleWidth < maxWidth) {
+    if (text[index] === "\u001b") {
+      const match = /\u001b\[[0-9;]*m/.exec(text.slice(index));
+      if (!match) {
+        break;
+      }
+      output += match[0];
+      index += match[0].length;
+      continue;
+    }
+
+    output += text[index];
+    visibleWidth += 1;
+    index += 1;
+  }
+
+  return output;
+}

package/src/testing/reporter/reporter.types.ts

@@ -3,6 +3,9 @@ import type { OpStep, ScenarioSpec } from "../contracts/testing-metadata.types";
 import type { SolidTestSpecResult } from "../contracts/test-spec.types";
 
 export interface Reporter {
+  onRunStart?(args: {
+    total: number;
+  }): void;
   onScenarioStart(scenario: ScenarioSpec): void;
   onScenarioEnd(
     scenario: ScenarioSpec,

package/src/testing/runner/run-from-metadata.ts

@@ -67,6 +67,7 @@ export async function runFromMetadata(opts: RunnerOptions): Promise<void> {
 
   const resources = new SimpleResourceStore();
   const reporter = opts.reporter ?? new ConsoleReporter();
+  reporter.onRunStart?.({ total: scenarios.length });
   const api = new ApiAdapter(opts.api);
   const { PlaywrightAdapter } = await import("../adapters/ui/playwright-adapter");
   const ui = new PlaywrightAdapter(opts.ui);

package/src/theme/theme-registry.ts

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Backend theme registry.
+ *
+ * Responsibilities:
+ * - discover theme folders from the filesystem
+ * - classify each theme as light/dark from its key
+ * - expose default and grouped theme helpers for backend settings
+ *
+ * Shared pure parsing helpers are intentionally mirrored in solid-core-ui,
+ * but all filesystem discovery stays here.
+ */
+export type ThemeMode = "light" | "dark";
+
+export type AppThemeDefinition = {
+  key: string;
+  label: string;
+  mode: ThemeMode;
+  default?: boolean;
+};
+
+const DEFAULT_THEME_KEYS: Record<ThemeMode, string> = {
+  light: "solid-light-purple",
+  dark: "solid-dark-purple",
+};
+
+const THEME_MODE_TOKENS: Record<ThemeMode, string> = {
+  light: "-light-",
+  dark: "-dark-",
+};
+
+const THEME_MODE_SUFFIXES: Record<ThemeMode, string> = {
+  light: "-light",
+  dark: "-dark",
+};
+
+function normalizeThemeKey(value?: string | null): string | null {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || null;
+}
+
+function matchesThemeMode(value: string, mode: ThemeMode): boolean {
+  return (
+    value.includes(THEME_MODE_TOKENS[mode])
+    || value.endsWith(THEME_MODE_SUFFIXES[mode])
+    || value === mode
+  );
+}
+
+function titleCase(value: string): string {
+  return value
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((token) => {
+      if (token.toLowerCase() === "solid") return "SolidX";
+      return token.charAt(0).toUpperCase() + token.slice(1);
+    })
+    .join(" ");
+}
+
+export function getThemeModeFromThemeKey(value?: string | null): ThemeMode | null {
+  const normalized = normalizeThemeKey(value);
+  if (!normalized) return null;
+
+  if (matchesThemeMode(normalized, "light")) return "light";
+  if (matchesThemeMode(normalized, "dark")) return "dark";
+
+  return null;
+}
+
+function createThemeDefinition(key: string, defaultTheme = false): AppThemeDefinition {
+  const mode = getThemeModeFromThemeKey(key);
+  if (!mode) {
+    throw new Error(`Invalid theme key: ${key}`);
+  }
+
+  return {
+    key,
+    label: titleCase(key),
+    mode,
+    default: defaultTheme,
+  };
+}
+
+function createDefaultTheme(mode: ThemeMode): AppThemeDefinition {
+  return createThemeDefinition(DEFAULT_THEME_KEYS[mode], true);
+}
+
+function groupThemesByMode(themes: AppThemeDefinition[], mode: ThemeMode): AppThemeDefinition[] {
+  return themes.filter((theme) => theme.mode === mode);
+}
+
+function pickDefaultThemeKey(themes: AppThemeDefinition[], mode: ThemeMode): string {
+  const themesForMode = groupThemesByMode(themes, mode);
+
+  return (
+    themesForMode.find((theme) => theme.default)?.key
+    ?? themesForMode[0]?.key
+    ?? DEFAULT_THEME_KEYS[mode]
+  );
+}
+
+function resolveThemeDirectory(): string | null {
+  const themeDirectory = path.resolve(process.cwd(), "..", "solid-ui", "public", "themes");
+  try {
+    if (fs.existsSync(themeDirectory) && fs.statSync(themeDirectory).isDirectory()) {
+      return path.resolve(themeDirectory);
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function isThemeDirectory(themeDirectory: string, entryName: string): boolean {
+  return fs.existsSync(path.join(themeDirectory, entryName, "theme.css"));
+}
+
+function readThemesFromPath(): AppThemeDefinition[] {
+  const themeDirectory = resolveThemeDirectory();
+  if (!themeDirectory) {
+    return [];
+  }
+
+  try {
+    const directoryEntries = fs.readdirSync(themeDirectory, { withFileTypes: true });
+
+    return directoryEntries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name.trim())
+      .filter(Boolean)
+      .filter((entryName) => isThemeDirectory(themeDirectory, entryName))
+      .flatMap((entryName) => {
+        const mode = getThemeModeFromThemeKey(entryName);
+        if (!mode) return [];
+
+        return [createThemeDefinition(entryName, entryName === DEFAULT_THEME_KEYS[mode])];
+      })
+      .sort((left, right) => left.label.localeCompare(right.label));
+  } catch {
+    return [];
+  }
+}
+
+function getThemes(): AppThemeDefinition[] {
+  const discoveredThemes = readThemesFromPath();
+
+  if (discoveredThemes.length) {
+    return discoveredThemes;
+  }
+
+  return [createDefaultTheme("light"), createDefaultTheme("dark")];
+}
+
+export function getCoreThemes(): AppThemeDefinition[] {
+  return getThemes();
+}
+
+export function getRegisteredThemes(): AppThemeDefinition[] {
+  return getThemes();
+}
+
+export function getThemesByMode(mode: ThemeMode): AppThemeDefinition[] {
+  return groupThemesByMode(getRegisteredThemes(), mode);
+}
+
+export function getDefaultThemeKey(mode: ThemeMode = "light"): string {
+  return pickDefaultThemeKey(getRegisteredThemes(), mode);
+}
+
+export function isRegisteredThemeKey(value?: string | null, mode?: ThemeMode): value is string {
+  if (!value) return false;
+
+  return getRegisteredThemes().some((theme) => {
+    if (theme.key !== value) return false;
+    return mode ? theme.mode === mode : true;
+  });
+}

package/CLAUDE.md

@@ -1,26 +0,0 @@
-# This is the SolidX API project.
-This is included as a dependency in consuming projects.
-
-# SolidX UI
-# The corresponding UI project is at the below path:
- /Users/oswald/projects/Solid_Starters/solid-core-ui
-
-# SolidX Docs
-# The documentation project is at the below path:
-/Users/oswald/projects/solidxai-docs
-
-# SolidX Agent
-# The agent project which has the skills for helping users configure, build and use SolidX is at the below path:
-/Users/oswald/projects/Solid_Starters/agent
-
-# SolidX Control Plane Commands
-# The control plane commands for managing SolidX instances are in the below path:
-/Users/oswald/projects/Solid_Starters/solidctl
-
-# Testing reference project 
-# This is the reference library management project that is used for testing and development of SolidX features. It is located at the below path:
-/Users/oswald/projects/Solid_Starters/solid-library-management
-
-# Code Builder project
-# This is the project that contains the code builder which generates code based on user input and templates. It is located at the below path:
-/Users/oswald/projects/Solid_Starters/solid-code-builder