@h-rig/cli 0.0.6-alpha.89 → 0.0.6-alpha.90

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

@@ -1,186 +0,0 @@
-// @bun
-var __require = import.meta.require;
-
-// packages/cli/src/app-opentui/adapters/common.ts
-function projectRootOf(ctx) {
-  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
-  if (typeof root === "string" && root.trim())
-    return root;
-  throw new Error("App adapter requires a projectRoot.");
-}
-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;
-  }
-}
-
-// packages/cli/src/app-opentui/adapters/repo.ts
-function repoActionRequest(ctx) {
-  const intent = ctx.getState().intent;
-  const payload = intent?.action?.payload;
-  if (!payload)
-    return { kind: "none" };
-  if (payload.repoReset === true)
-    return { kind: "reset" };
-  const alias = payload.repoSync;
-  if (typeof alias === "string" && alias.trim())
-    return { kind: "sync", alias: alias.trim() };
-  return { kind: "none" };
-}
-function readRepoGitStatus(projectRoot, checkoutRoot, pinnedCommit, runCapture, existsSync, joinPath) {
-  const unavailable = { available: false, clean: false, dirtyCount: 0, head: "", branch: "", ahead: 0, behind: 0 };
-  if (!checkoutRoot || !existsSync(joinPath(checkoutRoot, ".git")))
-    return unavailable;
-  const porcelain = runCapture(["git", "-C", checkoutRoot, "status", "--porcelain"], projectRoot);
-  if (porcelain.exitCode !== 0)
-    return unavailable;
-  const dirtyLines = porcelain.stdout.split(/\r?\n/).filter((row) => row.trim().length > 0);
-  const head = runCapture(["git", "-C", checkoutRoot, "rev-parse", "--short", "HEAD"], projectRoot).stdout.trim();
-  const branchRaw = runCapture(["git", "-C", checkoutRoot, "rev-parse", "--abbrev-ref", "HEAD"], projectRoot).stdout.trim();
-  let ahead = 0;
-  let behind = 0;
-  if (pinnedCommit) {
-    const counts = runCapture(["git", "-C", checkoutRoot, "rev-list", "--left-right", "--count", `${pinnedCommit}...HEAD`], projectRoot);
-    if (counts.exitCode === 0) {
-      const [behindStr = "0", aheadStr = "0"] = counts.stdout.trim().split(/\s+/);
-      behind = Number.parseInt(behindStr, 10) || 0;
-      ahead = Number.parseInt(aheadStr, 10) || 0;
-    }
-  }
-  return {
-    available: true,
-    clean: dirtyLines.length === 0,
-    dirtyCount: dirtyLines.length,
-    head,
-    branch: branchRaw && branchRaw !== "HEAD" ? branchRaw : "(detached)",
-    ahead,
-    behind
-  };
-}
-async function refreshRepo(ctx) {
-  const request = repoActionRequest(ctx);
-  const label = request.kind === "sync" ? `Syncing ${request.alias}` : request.kind === "reset" ? "Resetting repo baseline" : "Loading repo state";
-  emitStarted(ctx, label);
-  try {
-    const projectRoot = projectRootOf(ctx);
-    const [
-      { repoBaseline, resetBaseline },
-      { currentTaskId },
-      { listManagedRepoEntries, resolveManagedRepoIdByAlias },
-      { syncManagedRepo, resolveManagedRepoLayoutByAlias },
-      { runCapture },
-      { existsSync },
-      pathMod
-    ] = await Promise.all([
-      import("@rig/runtime/control-plane/native/repo-ops"),
-      import("@rig/runtime/control-plane/native/task-state"),
-      import("@rig/runtime/control-plane/repos/registry"),
-      import("@rig/runtime/control-plane/repos"),
-      import("@rig/runtime/control-plane/native/utils"),
-      import("fs"),
-      import("path")
-    ]);
-    const joinPath = (...parts) => pathMod.resolve(...parts);
-    if (request.kind === "sync") {
-      const repoId = resolveManagedRepoIdByAlias(request.alias);
-      if (!repoId)
-        throw new Error(`No managed repo registered for alias ${request.alias}.`);
-      emitProgress(ctx, label, `re-syncing ${request.alias} from its remote default branch`);
-      await captureConsole(() => syncManagedRepo(projectRoot, repoId));
-    } else if (request.kind === "reset") {
-      emitProgress(ctx, label, "resetting baseline to origin/main and refreshing pins");
-      await captureConsole(() => resetBaseline(projectRoot, false));
-    }
-    emitProgress(ctx, label, "reading baseline pins and managed repos");
-    const { result } = await captureConsole(() => ({
-      pins: repoBaseline(projectRoot, false),
-      taskId: currentTaskId(projectRoot),
-      managed: listManagedRepoEntries()
-    }));
-    const baselinePins = Object.entries(result.pins).map(([alias, commit]) => ({ alias, commit: String(commit) }));
-    const pinByAlias = new Map(baselinePins.map((pin) => [pin.alias, pin.commit]));
-    const managedRepos = result.managed.map((entry) => {
-      const layout = resolveManagedRepoLayoutByAlias(projectRoot, entry.alias);
-      const git = layout ? readRepoGitStatus(projectRoot, layout.checkoutRoot, pinByAlias.get(entry.alias), runCapture, existsSync, joinPath) : undefined;
-      return {
-        id: entry.id,
-        alias: entry.alias,
-        defaultBranch: entry.defaultBranch,
-        defaultRemoteUrl: entry.defaultRemoteUrl,
-        ...git ? { git } : {}
-      };
-    });
-    const snapshot = {
-      activeTaskId: result.taskId.trim() ? result.taskId.trim() : null,
-      baselinePins,
-      managedRepos,
-      flatLayout: managedRepos.length === 0,
-      refreshedAt: Date.now()
-    };
-    patchData(ctx, { repo: snapshot, lastRefreshError: undefined });
-    patchFooter(ctx, { message: snapshot.flatLayout ? "flat layout \xB7 no managed repos" : `${managedRepos.length} managed repos \xB7 ${baselinePins.length} pins` });
-    emitCompleted(ctx, label, { managed: managedRepos.length, pins: baselinePins.length, task: snapshot.activeTaskId });
-    return snapshot;
-  } catch (error) {
-    emitFailed(ctx, label, error);
-    throw error;
-  }
-}
-export {
-  refreshRepo
-};

package/dist/src/app-opentui/adapters/run-detail.d.ts

@@ -1,27 +0,0 @@
-import { type AppAdapterContext } from "./common";
-export type AppRunSnapshot = {
-    readonly runId: string;
-    readonly status: string;
-    readonly title: string;
-    readonly run: Record<string, unknown>;
-    readonly logs: Record<string, unknown>[];
-    readonly timeline: Record<string, unknown>[];
-    readonly timelineCursor: string | null;
-    /** Server-reported totals (when available) so the scene can show "N of M" and
-     * decide whether a "load more" affordance is warranted (#2). */
-    readonly logsTotal?: number;
-    readonly timelineTotal?: number;
-};
-export declare function loadRunDetail(ctx: AppAdapterContext, runId: string, options?: {
-    readonly timelineCursor?: string | null;
-}): Promise<AppRunSnapshot>;
-/** "Load more" for the timeline (#2): fetch the NEXT page using the stored
- * `timelineCursor` and APPEND it to the existing snapshot, advancing the cursor.
- * The previously-loaded rows stay; nothing is re-fetched. No cursor ⇒ nothing
- * more to load (the scene only offers the affordance while a cursor exists). */
-export declare function loadMoreRunTimeline(ctx: AppAdapterContext, runId: string): Promise<AppRunSnapshot | null>;
-export declare function steerRunFromApp(ctx: AppAdapterContext, input: {
-    readonly runId: string;
-    readonly message: string;
-}): Promise<Record<string, unknown>>;
-export declare function stopRunFromDetail(ctx: AppAdapterContext, runId: string): Promise<Record<string, unknown>>;