@h-rig/cli 0.0.6-alpha.8 → 0.0.6-alpha.81

package/dist/src/app-opentui/adapters/common.js

@@ -0,0 +1,149 @@
+// @bun
+// packages/cli/src/app-opentui/adapters/common.ts
+function adapterContextFromRuntime(runtime, renderer) {
+  return {
+    projectRoot: runtime.getState().projectRoot,
+    renderer,
+    ensureRuntime: () => runtime.getRunnerContext(),
+    emit: (event) => runtime.emit(event),
+    getState: () => runtime.getState()
+  };
+}
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("Rig app adapter requires a projectRoot.");
+}
+async function runtimeOf(ctx) {
+  if (ctx.rig && "runId" in ctx.rig && ctx.ensureRuntime === undefined) {
+    return ctx.rig;
+  }
+  if (ctx.ensureRuntime)
+    return ctx.ensureRuntime();
+  throw new Error("Rig app adapter requires ensureRuntime() before this action can run.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+async function captureConsole(fn) {
+  const output = [];
+  const original = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  const capture = (...parts) => {
+    output.push(parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" "));
+  };
+  console.log = capture;
+  console.info = capture;
+  console.warn = capture;
+  console.error = capture;
+  try {
+    const result = await fn();
+    return { result, output };
+  } finally {
+    console.log = original.log;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+  }
+}
+async function releaseRendererForExternalTui(ctx) {
+  const renderer = ctx.renderer;
+  if (!renderer)
+    return;
+  if (renderer.suspend) {
+    await renderer.suspend();
+    return;
+  }
+  if (renderer.destroy) {
+    await renderer.destroy();
+  }
+}
+function arrayFromPayload(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const entries = value.entries;
+    if (Array.isArray(entries))
+      return arrayFromPayload(entries);
+  }
+  return [];
+}
+function stringField(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return fallback;
+}
+function compactRecord(record, keys) {
+  const out = {};
+  for (const key of keys) {
+    const value = record[key];
+    if (value !== undefined && value !== null && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+function payloadString(intent, key) {
+  const value = intent.action.payload?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export {
+  stringField,
+  runtimeOf,
+  releaseRendererForExternalTui,
+  projectRootOf,
+  payloadString,
+  patchFooter,
+  patchData,
+  normalizeAppError,
+  emitStarted,
+  emitProgress,
+  emitFailed,
+  emitCompleted,
+  compactRecord,
+  captureConsole,
+  arrayFromPayload,
+  adapterContextFromRuntime
+};

package/dist/src/app-opentui/adapters/doctor.d.ts

@@ -0,0 +1,11 @@
+import type { AppAdapter } from "../types";
+import { type AppAdapterContext } from "./common";
+export declare function createDoctorAdapter(): AppAdapter;
+export type AppDoctorCheck = {
+    readonly id: string;
+    readonly label: string;
+    readonly status: "pass" | "warn" | "fail";
+    readonly detail?: string;
+    readonly remediation?: string;
+};
+export declare function runDoctorChecksForApp(ctx: AppAdapterContext): Promise<AppDoctorCheck[]>;