@h-rig/init-lib 0.0.6-alpha.158

package/dist/src/setup.d.ts

@@ -0,0 +1,121 @@
+import { spawnSync } from "node:child_process";
+import { type GitHubAuthStatus, type GitHubUserFetcher } from "@rig/github-lib";
+import { type PlacementKind } from "@rig/core/placement";
+export type RigConfigStatus = {
+    readonly exists: boolean;
+    readonly valid: boolean;
+    readonly path: string;
+    readonly slug: string | null;
+    readonly reason?: string;
+};
+export type RigStateStatus = {
+    readonly valid: boolean;
+    readonly selected: string | null;
+    readonly project: string | null;
+    readonly reason?: string;
+};
+export type RigAuthValidation = {
+    readonly ok: boolean;
+    readonly source: "stored-token" | "gh" | "missing";
+    readonly login?: string | null;
+    readonly detail: string;
+    readonly status?: GitHubAuthStatus;
+};
+export type RigSetupStatus = {
+    readonly configured: boolean;
+    readonly projectRoot: string;
+    readonly slug: string | null;
+    readonly config: RigConfigStatus;
+    readonly state: RigStateStatus;
+    readonly auth: RigAuthValidation;
+    readonly reasons: readonly string[];
+};
+export type RigSetupPlacement = {
+    readonly alias: string;
+    readonly kind: PlacementKind;
+    readonly host?: string;
+    readonly port?: number;
+    readonly token?: string | null;
+};
+export type RigSetupDeps = {
+    readonly spawn?: typeof spawnSync;
+    readonly fetch?: typeof fetch;
+    readonly fetchUser?: GitHubUserFetcher;
+};
+export type RunSetupInput = {
+    readonly projectRoot: string;
+    readonly slug: string;
+    readonly placement: RigSetupPlacement;
+    readonly rewriteConfig?: boolean | undefined;
+    readonly ensurePi?: boolean | undefined;
+    readonly githubToken?: string | null | undefined;
+    readonly importGhToken?: boolean | undefined;
+    readonly ensureLabels?: boolean | undefined;
+    readonly deps?: RigSetupDeps | undefined;
+};
+export declare function parseRepoSlugFromRemote(remoteUrl: string): string | null;
+export declare function parseRepoSlug(value: string): {
+    owner: string;
+    repo: string;
+    slug: string;
+};
+export declare function detectOriginRepoSlug(projectRoot: string, deps?: RigSetupDeps): string | null;
+export declare function ensureRigPrivateDirs(projectRoot: string): void;
+export declare function ensureGitignoreEntries(projectRoot: string): void;
+export declare function writeRigConnectionState(projectRoot: string, slug: string, placement: RigSetupPlacement): void;
+export declare function writeRigConfig(projectRoot: string, slug: string): void;
+export declare function readRigConfigStatus(projectRoot: string): RigConfigStatus;
+export declare function readRigConnectionStatus(projectRoot: string): RigStateStatus;
+export declare function detectGhAuth(projectRoot: string, slug: string, deps?: RigSetupDeps): RigAuthValidation | null;
+export declare function validateGitHubAuth(projectRoot: string, slug: string | null, deps?: RigSetupDeps): Promise<RigAuthValidation>;
+export declare function saveGitHubTokenLocally(projectRoot: string, token: string, slug: string, deps?: RigSetupDeps): Promise<void>;
+export declare function readGhAuthToken(projectRoot: string, deps?: RigSetupDeps): string;
+export declare function ensureGitHubAuth(input: {
+    projectRoot: string;
+    slug: string;
+    token?: string | null | undefined;
+    importGhToken?: boolean | undefined;
+    deps?: RigSetupDeps | undefined;
+}): Promise<RigAuthValidation>;
+export declare function ensureGitHubLabels(input: {
+    projectRoot: string;
+    slug: string;
+    token?: string | null;
+    deps?: RigSetupDeps | undefined;
+}): Promise<{
+    ok: true;
+    method: "api" | "gh";
+    labels: readonly string[];
+}>;
+export declare function ensurePiRigInstalledForSetup(projectRoot: string, deps?: RigSetupDeps): {
+    ok: true;
+    detail: string;
+};
+export declare function detectRigStartupStatus(input: {
+    projectRoot: string;
+    deps?: RigSetupDeps | undefined;
+}): Promise<RigSetupStatus>;
+export declare const detectStartupStatus: typeof detectRigStartupStatus;
+export declare function applyRigSetupProject(input: {
+    projectRoot: string;
+    slug: string;
+    placement: RigSetupPlacement;
+    rewriteConfig: boolean;
+    ensurePi?: boolean | undefined;
+    ensureLabels?: boolean | undefined;
+    deps?: RigSetupDeps | undefined;
+}): Promise<{
+    repoSlug: string;
+    placement: string;
+    configWritten: boolean;
+    labels: unknown;
+    pi: unknown;
+}>;
+export declare function runSetup(input: RunSetupInput): Promise<{
+    repoSlug: string;
+    placement: string;
+    configWritten: boolean;
+    labels: unknown;
+    pi: unknown;
+    status: RigSetupStatus;
+}>;

package/dist/src/setup.js

@@ -0,0 +1,455 @@
+// @bun
+// packages/init-lib/src/setup.ts
+import { spawnSync } from "child_process";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import {
+  createGitHubAuthStore,
+  probeGitHubRepository,
+  resolveGitHubAuthStatus,
+  saveGitHubTokenForProject
+} from "@rig/github-lib";
+import { addPlacement, selectPlacement } from "@rig/core/placement";
+
+// packages/init-lib/src/ensure-config.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { stringify as stringifyToml } from "smol-toml";
+import { getStandardPluginsResolver } from "@rig/core/embedded-plugins";
+function rigfigConfigPath(projectRoot) {
+  return resolve(projectRoot, ".rig", "rigfig.toml");
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function deepMerge(base, overlay) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    const prev = out[key];
+    out[key] = isPlainObject(prev) && isPlainObject(value) ? deepMerge(prev, value) : value;
+  }
+  return out;
+}
+function composeDeclarativeConfig(plugins, context) {
+  let merged = {};
+  for (const plugin of plugins) {
+    const fragment = plugin.contributes?.config?.defaults?.(context);
+    if (isPlainObject(fragment))
+      merged = deepMerge(merged, fragment);
+  }
+  return merged;
+}
+var HEADER = [
+  "# Declarative rig configuration \u2014 the happy path.",
+  "# Plain DATA, composed from the standard plugins' defaults. No top-level",
+  "# rig.config.ts and no @h-rig/* install: the global rig binary resolves",
+  "# plugins from its embedded standard collection. rig created this for you;",
+  "# edit it freely (each plugin owns the section it needs).",
+  "",
+  ""
+].join(`
+`);
+function writeRigfigConfig(projectRoot, config) {
+  mkdirSync(resolve(projectRoot, ".rig"), { recursive: true });
+  const path = rigfigConfigPath(projectRoot);
+  writeFileSync(path, `${HEADER}${stringifyToml(config)}
+`, "utf-8");
+  return path;
+}
+function composeAndWriteRigfig(projectRoot, options = {}) {
+  const resolver = getStandardPluginsResolver();
+  if (!resolver) {
+    throw new Error("Cannot write rig config: embedded standard plugins are not registered (seed wiring error).");
+  }
+  const context = options.repoSlug ? { projectRoot, repoSlug: options.repoSlug } : { projectRoot };
+  let composed = composeDeclarativeConfig(resolver(), context);
+  if (options.overlay) {
+    if (isPlainObject(options.overlay.taskSource) && "taskSource" in composed)
+      delete composed.taskSource;
+    composed = deepMerge(composed, options.overlay);
+  }
+  return writeRigfigConfig(projectRoot, composed);
+}
+
+// packages/init-lib/src/setup.ts
+var RIG_LABELS_TO_ENSURE = [
+  "rig:running",
+  "rig:pr-open",
+  "rig:ci-fixing",
+  "rig:merging",
+  "rig:done",
+  "rig:needs-attention",
+  "rig:ready",
+  "rig:blocked",
+  "rig:generated"
+];
+var RIG_LABEL_METADATA = {
+  "rig:running": { color: "1d76db", description: "Rig is actively working on this issue." },
+  "rig:pr-open": { color: "5319e7", description: "Rig opened a pull request for this issue." },
+  "rig:ci-fixing": { color: "fbca04", description: "Rig is fixing CI or review feedback for this issue." },
+  "rig:merging": { color: "0052cc", description: "Rig is merging the completed change for this issue." },
+  "rig:done": { color: "0e8a16", description: "Rig completed this issue." },
+  "rig:needs-attention": { color: "d93f0b", description: "Rig needs operator attention for this issue." },
+  "rig:ready": { color: "0e8a16", description: "Rig issue analysis marked this issue ready." },
+  "rig:blocked": { color: "d93f0b", description: "Rig issue analysis found blockers for this issue." },
+  "rig:generated": { color: "c5def5", description: "Rig generated this follow-up issue." }
+};
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parseRepoSlugFromRemote(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  const match = trimmed.match(/github\.com[:/]([^/\s]+)\/([^/\s.]+)(?:\.git)?$/i);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+function parseRepoSlug(value) {
+  const match = value.trim().match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (!match)
+    throw new Error(`Invalid GitHub repo slug "${value}". Expected owner/repo.`);
+  return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
+}
+function runSyncCommand(command, input = {}) {
+  const executable = command[0];
+  if (!executable)
+    throw new Error("command is required");
+  return (input.spawn ?? spawnSync)(executable, [...command.slice(1)], {
+    cwd: input.cwd,
+    encoding: "utf8",
+    timeout: input.timeoutMs ?? 1e4,
+    env: input.env ?? process.env
+  });
+}
+function detectOriginRepoSlug(projectRoot, deps = {}) {
+  const result = runSyncCommand(["git", "-C", projectRoot, "remote", "get-url", "origin"], { timeoutMs: 5000, spawn: deps.spawn });
+  if (result.status !== 0 || result.error)
+    return null;
+  return parseRepoSlugFromRemote(result.stdout.trim());
+}
+function connectionStatePath(projectRoot) {
+  return resolve2(projectRoot, ".rig", "state", "connection.json");
+}
+function projectLinkStatePath(projectRoot) {
+  return resolve2(projectRoot, ".rig", "state", "project-link.json");
+}
+function readJsonRecord(path) {
+  if (!existsSync2(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, value) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function ensureRigPrivateDirs(projectRoot) {
+  mkdirSync2(resolve2(projectRoot, ".rig", "state"), { recursive: true });
+  mkdirSync2(resolve2(projectRoot, ".rig", "logs"), { recursive: true });
+  mkdirSync2(resolve2(projectRoot, ".rig", "runs"), { recursive: true });
+  mkdirSync2(resolve2(projectRoot, ".rig", "tmp"), { recursive: true });
+  mkdirSync2(resolve2(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve2(projectRoot, ".rig", "task-config.json");
+  if (!existsSync2(taskConfigPath))
+    writeFileSync2(taskConfigPath, `{}
+`, "utf-8");
+}
+function ensureGitignoreEntries(projectRoot) {
+  const path = resolve2(projectRoot, ".gitignore");
+  const existing = existsSync2(path) ? readFileSync(path, "utf-8") : "";
+  const lines = new Set(existing.split(/\r?\n/));
+  const missing = [".rig/state/", ".rig/logs/", ".rig/runs/", ".rig/tmp/"].filter((entry) => !lines.has(entry));
+  if (missing.length === 0)
+    return;
+  const prefix = existing.length > 0 && !existing.endsWith(`
+`) ? `
+` : "";
+  appendFileSync(path, `${prefix}${missing.join(`
+`)}
+`, "utf-8");
+}
+function writeRigConnectionState(projectRoot, slug, placement) {
+  const previous = readJsonRecord(connectionStatePath(projectRoot)) ?? {};
+  writeJsonFile(connectionStatePath(projectRoot), {
+    ...previous,
+    selected: placement.alias,
+    project: slug,
+    linkedAt: new Date().toISOString()
+  });
+  writeJsonFile(projectLinkStatePath(projectRoot), {
+    repoSlug: slug,
+    connection: placement.alias,
+    linkedAt: new Date().toISOString()
+  });
+  if (placement.alias === "local")
+    delete process.env.RIG_REMOTE_ALIAS;
+  else
+    process.env.RIG_REMOTE_ALIAS = placement.alias;
+}
+function writeRigConfig(projectRoot, slug) {
+  parseRepoSlug(slug);
+  composeAndWriteRigfig(projectRoot, { repoSlug: slug });
+}
+function readRigConfigStatus(projectRoot) {
+  const path = rigfigConfigPath(projectRoot);
+  if (!existsSync2(path))
+    return { exists: false, valid: false, path, slug: null, reason: "missing .rig/rigfig.toml" };
+  try {
+    const source = readFileSync(path, "utf-8");
+    const owner = source.match(/^\s*owner\s*=\s*["']([^"']+)["']/m)?.[1] ?? null;
+    const repoValues = [...source.matchAll(/^\s*repo\s*=\s*["']([^"']+)["']/gm)].map((match) => match[1]).filter(Boolean);
+    const taskRepo = repoValues.find((value) => !value.includes("/")) ?? null;
+    const projectRepo = repoValues.find((value) => value.includes("/")) ?? null;
+    const githubIssues = /^\s*kind\s*=\s*["']github-issues["']/m.test(source);
+    const slug = owner && taskRepo ? `${owner}/${taskRepo}` : projectRepo;
+    if (!githubIssues || !slug)
+      return { exists: true, valid: false, path, slug: slug ?? null, reason: ".rig/rigfig.toml is not a GitHub Issues Rig config" };
+    parseRepoSlug(slug);
+    return { exists: true, valid: true, path, slug };
+  } catch (error) {
+    return { exists: true, valid: false, path, slug: null, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function readRigConnectionStatus(projectRoot) {
+  const stateDir = resolve2(projectRoot, ".rig", "state");
+  if (!existsSync2(stateDir))
+    return { valid: false, selected: null, project: null, reason: "missing .rig/state" };
+  const connection = readJsonRecord(connectionStatePath(projectRoot));
+  if (!connection)
+    return { valid: false, selected: null, project: null, reason: "missing or invalid .rig/state/connection.json" };
+  const selected = cleanString(connection.selected);
+  const project = cleanString(connection.project);
+  if (!selected)
+    return { valid: false, selected: null, project, reason: "connection.json is missing selected placement" };
+  if (!project)
+    return { valid: false, selected, project: null, reason: "connection.json is missing project slug" };
+  try {
+    parseRepoSlug(project);
+  } catch (error) {
+    return { valid: false, selected, project, reason: error instanceof Error ? error.message : String(error) };
+  }
+  return { valid: true, selected, project };
+}
+function detectGhAuth(projectRoot, slug, deps = {}) {
+  const user = runSyncCommand(["gh", "api", "user", "--jq", ".login"], { cwd: projectRoot, timeoutMs: 5000, spawn: deps.spawn });
+  if (user.status !== 0 || user.error || !user.stdout.trim())
+    return null;
+  const repo = runSyncCommand(["gh", "repo", "view", slug, "--json", "nameWithOwner", "--jq", ".nameWithOwner"], { cwd: projectRoot, timeoutMs: 5000, spawn: deps.spawn });
+  if (repo.status !== 0 || repo.error)
+    return { ok: false, source: "gh", login: user.stdout.trim(), detail: (repo.stderr || repo.stdout || "gh cannot access the selected repository").trim() };
+  return { ok: true, source: "gh", login: user.stdout.trim(), detail: "gh CLI authentication can access the selected repository" };
+}
+async function validateGitHubAuth(projectRoot, slug, deps = {}) {
+  if (!slug)
+    return { ok: false, source: "missing", detail: "GitHub repo slug is unknown" };
+  const status = resolveGitHubAuthStatus({ projectRoot, oauthConfigured: Boolean(process.env.RIG_GITHUB_OAUTH_CLIENT_ID?.trim()) });
+  if (status.signedIn) {
+    const store = createGitHubAuthStore(projectRoot);
+    if (!status.selectedRepo) {
+      store.saveSelectedRepo(slug);
+      return { ok: true, source: "stored-token", login: status.login, detail: "stored Rig GitHub token selected for this repo", status: store.status({ oauthConfigured: status.oauthConfigured }) };
+    }
+    if (status.selectedRepo !== slug)
+      return { ok: false, source: "stored-token", login: status.login, detail: `stored GitHub token is scoped to ${status.selectedRepo}, not ${slug}`, status };
+    return { ok: true, source: "stored-token", login: status.login, detail: "stored Rig GitHub token is present", status };
+  }
+  const gh = detectGhAuth(projectRoot, slug, deps);
+  if (gh)
+    return gh;
+  return { ok: false, source: "missing", detail: "Sign in with `gh auth login`, choose Setup \u2192 GitHub auth, or paste a token." };
+}
+async function saveGitHubTokenLocally(projectRoot, token, slug, deps = {}) {
+  ensureRigPrivateDirs(projectRoot);
+  await saveGitHubTokenForProject({
+    projectRoot,
+    token,
+    tokenSource: "manual-token",
+    selectedRepo: slug,
+    ...deps.fetchUser ? { fetchUser: deps.fetchUser } : {}
+  });
+  createGitHubAuthStore(projectRoot).copyToLocalProjectRoot(projectRoot);
+}
+function readGhAuthToken(projectRoot, deps = {}) {
+  const result = runSyncCommand(["gh", "auth", "token"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+  if (result.status !== 0 || result.error || !result.stdout.trim())
+    throw new Error((result.stderr || result.stdout || "Could not read GitHub token from `gh auth token`.").trim());
+  return result.stdout.trim();
+}
+async function ensureGitHubAuth(input) {
+  const current = await validateGitHubAuth(input.projectRoot, input.slug, input.deps);
+  if (current.ok && !input.token && !input.importGhToken)
+    return current;
+  if (input.token?.trim())
+    await saveGitHubTokenLocally(input.projectRoot, input.token.trim(), input.slug, input.deps);
+  else if (input.importGhToken)
+    await saveGitHubTokenLocally(input.projectRoot, readGhAuthToken(input.projectRoot, input.deps), input.slug, input.deps);
+  return validateGitHubAuth(input.projectRoot, input.slug, input.deps);
+}
+async function ensureGitHubLabels(input) {
+  const repo = parseRepoSlug(input.slug);
+  const token = input.token?.trim() || createGitHubAuthStore(input.projectRoot).readToken();
+  if (token) {
+    const fetchLabels = input.deps?.fetch ?? fetch;
+    for (const name of RIG_LABELS_TO_ENSURE) {
+      const metadata = RIG_LABEL_METADATA[name];
+      const response = await fetchLabels(`https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/labels`, {
+        method: "POST",
+        headers: {
+          accept: "application/vnd.github+json",
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json",
+          "user-agent": "rig"
+        },
+        body: JSON.stringify({ name, color: metadata.color, description: metadata.description })
+      });
+      if (response.ok)
+        continue;
+      const text = await response.text().catch(() => "");
+      if (response.status === 422 && /already_exists|already exists|exists/i.test(text))
+        continue;
+      throw new Error(`Could not create GitHub label ${name}: ${response.status} ${text || response.statusText}`);
+    }
+    return { ok: true, method: "api", labels: RIG_LABELS_TO_ENSURE };
+  }
+  const gh = detectGhAuth(input.projectRoot, input.slug, input.deps);
+  if (!gh?.ok)
+    throw new Error("GitHub labels require a stored Rig token or gh auth.");
+  for (const name of RIG_LABELS_TO_ENSURE) {
+    const metadata = RIG_LABEL_METADATA[name];
+    const result = runSyncCommand(["gh", "label", "create", name, "--repo", input.slug, "--color", metadata.color, "--description", metadata.description, "--force"], { cwd: input.projectRoot, timeoutMs: 1e4, spawn: input.deps?.spawn });
+    if (result.status !== 0 || result.error)
+      throw new Error(`gh label create ${name} failed: ${(result.stderr || result.stdout || result.error?.message || "unknown error").trim()}`);
+  }
+  return { ok: true, method: "gh", labels: RIG_LABELS_TO_ENSURE };
+}
+function piListContainsRigExtension(output) {
+  return output.split(/\r?\n/).some((line) => line.includes("@h-rig/pi-rig") || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(line));
+}
+function splitInstallCommand(value) {
+  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^["']|["']$/g, "")) ?? [];
+}
+function ensurePiRigInstalledForSetup(projectRoot, deps = {}) {
+  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1")
+    return { ok: true, detail: "fake-pi" };
+  let version = runSyncCommand(["pi", "--version"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+  if (version.status !== 0 || version.error) {
+    const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim();
+    if (!installCommand)
+      throw new Error(`Pi/OMP is not available: ${(version.stderr || version.stdout || version.error?.message || "pi --version failed").trim()}. Install Pi/OMP or set RIG_PI_INSTALL_COMMAND.`);
+    const parts = splitInstallCommand(installCommand);
+    if (parts.length === 0)
+      throw new Error("RIG_PI_INSTALL_COMMAND is empty.");
+    const install = runSyncCommand(parts, { cwd: projectRoot, timeoutMs: 120000, spawn: deps.spawn });
+    if (install.status !== 0 || install.error)
+      throw new Error(`Pi/OMP install command failed: ${(install.stderr || install.stdout || install.error?.message || "unknown error").trim()}`);
+    version = runSyncCommand(["pi", "--version"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+    if (version.status !== 0 || version.error)
+      throw new Error(`Pi/OMP is still unavailable after install: ${(version.stderr || version.stdout || version.error?.message || "pi --version failed").trim()}`);
+  }
+  let list = runSyncCommand(["pi", "list"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+  if (!piListContainsRigExtension(`${list.stdout}
+${list.stderr}`)) {
+    const packageSource = existsSync2(resolve2(projectRoot, "packages", "pi-rig", "package.json")) ? resolve2(projectRoot, "packages", "pi-rig") : "npm:@h-rig/pi-rig";
+    const install = runSyncCommand(["pi", "install", packageSource], { cwd: projectRoot, timeoutMs: 120000, spawn: deps.spawn });
+    if (install.status !== 0 || install.error)
+      throw new Error(`Could not install/register the Rig OMP extension: ${(install.stderr || install.stdout || install.error?.message || "pi install failed").trim()}`);
+    list = runSyncCommand(["pi", "list"], { cwd: projectRoot, timeoutMs: 1e4, spawn: deps.spawn });
+    if (!piListContainsRigExtension(`${list.stdout}
+${list.stderr}`))
+      throw new Error("Pi/OMP is installed, but `pi list` does not show the Rig extension.");
+  }
+  return { ok: true, detail: (version.stdout || version.stderr).trim() || "pi available; rig extension registered" };
+}
+async function detectRigStartupStatus(input) {
+  const projectRoot = input.projectRoot;
+  const config = readRigConfigStatus(projectRoot);
+  const state = readRigConnectionStatus(projectRoot);
+  const detectedSlug = detectOriginRepoSlug(projectRoot, input.deps);
+  const slug = config.slug ?? state.project ?? detectedSlug;
+  const reasons = [];
+  if (!detectedSlug)
+    reasons.push("git origin does not point at a GitHub owner/repo remote");
+  if (!config.exists || !config.valid)
+    reasons.push(config.reason ?? "rig.config.ts is invalid");
+  if (!state.valid)
+    reasons.push(state.reason ?? ".rig/state/connection.json is invalid");
+  if (config.slug && state.project && config.slug !== state.project)
+    reasons.push(`rig.config.ts repo ${config.slug} does not match connection project ${state.project}`);
+  if (slug && detectedSlug && slug !== detectedSlug)
+    reasons.push(`configured repo ${slug} does not match git origin ${detectedSlug}`);
+  const auth = await validateGitHubAuth(projectRoot, slug, input.deps);
+  if (!auth.ok)
+    reasons.push(auth.detail);
+  return { configured: reasons.length === 0, projectRoot, slug, config, state, auth, reasons };
+}
+var detectStartupStatus = detectRigStartupStatus;
+async function applyRigSetupProject(input) {
+  const repo = parseRepoSlug(input.slug);
+  ensureRigPrivateDirs(input.projectRoot);
+  ensureGitignoreEntries(input.projectRoot);
+  if (input.placement.alias !== "local" && input.placement.host) {
+    addPlacement(input.projectRoot, { alias: input.placement.alias, host: input.placement.host, ...input.placement.port !== undefined ? { port: input.placement.port } : {}, ...input.placement.token !== undefined ? { token: input.placement.token } : {}, select: true });
+  } else {
+    selectPlacement(input.projectRoot, input.placement.alias);
+  }
+  writeRigConnectionState(input.projectRoot, repo.slug, input.placement);
+  if (input.rewriteConfig)
+    writeRigConfig(input.projectRoot, repo.slug);
+  const labels = input.ensureLabels === false ? { skipped: true } : await ensureGitHubLabels({ projectRoot: input.projectRoot, slug: repo.slug, deps: input.deps });
+  const pi = input.ensurePi === false ? { skipped: true } : ensurePiRigInstalledForSetup(input.projectRoot, input.deps);
+  return { repoSlug: repo.slug, placement: input.placement.alias, configWritten: input.rewriteConfig, labels, pi };
+}
+async function runSetup(input) {
+  const repo = parseRepoSlug(input.slug);
+  const auth = await ensureGitHubAuth({ projectRoot: input.projectRoot, slug: repo.slug, token: input.githubToken, importGhToken: input.importGhToken, deps: input.deps });
+  if (!auth.ok)
+    throw new Error(auth.detail);
+  const token = createGitHubAuthStore(input.projectRoot).readToken();
+  const probe = await probeGitHubRepository({
+    owner: repo.owner,
+    repo: repo.repo,
+    token,
+    scopes: auth.status?.scopes ?? [],
+    ...input.deps?.fetch ? { fetchRepository: input.deps.fetch } : {}
+  });
+  if (!probe.ok)
+    throw new Error(probe.message);
+  const result = await applyRigSetupProject({
+    projectRoot: input.projectRoot,
+    slug: repo.slug,
+    placement: input.placement,
+    rewriteConfig: input.rewriteConfig ?? true,
+    ensurePi: input.ensurePi,
+    ensureLabels: input.ensureLabels,
+    deps: input.deps
+  });
+  const status = await detectRigStartupStatus({ projectRoot: input.projectRoot, deps: input.deps });
+  if (!status.configured)
+    throw new Error(`Setup wrote state but doctor still reports: ${status.reasons.join("; ")}`);
+  return { ...result, status };
+}
+export {
+  writeRigConnectionState,
+  writeRigConfig,
+  validateGitHubAuth,
+  saveGitHubTokenLocally,
+  runSetup,
+  readRigConnectionStatus,
+  readRigConfigStatus,
+  readGhAuthToken,
+  parseRepoSlugFromRemote,
+  parseRepoSlug,
+  ensureRigPrivateDirs,
+  ensurePiRigInstalledForSetup,
+  ensureGitignoreEntries,
+  ensureGitHubLabels,
+  ensureGitHubAuth,
+  detectStartupStatus,
+  detectRigStartupStatus,
+  detectOriginRepoSlug,
+  detectGhAuth,
+  applyRigSetupProject
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@h-rig/init-lib",
+  "version": "0.0.6-alpha.158",
+  "type": "module",
+  "description": "Rig init/onboarding library (config-source codegen, setup runner, GitHub-auth + startup detection) — non-plugin domain library shared by the cli surface, the rig extension, and the init plugin.",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./index": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./ensure-config": {
+      "types": "./dist/src/ensure-config.d.ts",
+      "import": "./dist/src/ensure-config.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.158",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.158",
+    "@rig/github-lib": "npm:@h-rig/github-lib@0.0.6-alpha.158"
+  }
+}