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

package/dist/src/index.js

@@ -0,0 +1,704 @@
+// @bun
+// packages/init-lib/src/dependency-preflight.ts
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { basename, join, resolve } from "path";
+var REQUIRED_RIG_CONFIG_PACKAGE_NAMES = ["core", "standard-plugin"];
+var RIG_CONFIG_FILENAMES = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
+var DEPENDENCY_SECTION_NAMES = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+var INSTALL_CHECK_SECTION_NAMES = ["dependencies", "devDependencies", "optionalDependencies"];
+function hasRigConfig(projectRoot) {
+  const root = resolve(projectRoot);
+  return RIG_CONFIG_FILENAMES.some((name) => existsSync(join(root, name)));
+}
+function resolveRigConfigPackageVersion(input) {
+  const explicit = process.env.RIG_CONFIG_PACKAGE_VERSION?.trim();
+  if (explicit)
+    return explicit;
+  return input.isInstalledCliVersionPublished ? input.installedCliVersion : "latest";
+}
+function readPackageManifest(path) {
+  if (!existsSync(path))
+    return null;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function mutableDeps(manifest, key) {
+  const source = manifest[key];
+  return source && typeof source === "object" && !Array.isArray(source) ? { ...source } : {};
+}
+function rigPackageName(name) {
+  const match = name.match(/^@rig\/([^/]+)$/);
+  return match?.[1] ?? null;
+}
+function rigPackageNameFromSpecifier(specifier) {
+  const match = specifier.match(/^@rig\/([^/]+)/);
+  return match?.[1] ?? null;
+}
+function rigPackageSpec(projectRoot, packageName, version) {
+  const localManifestPath = join(projectRoot, "packages", packageName, "package.json");
+  if (existsSync(localManifestPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(localManifestPath, "utf8"));
+      if (parsed.name === `@rig/${packageName}`)
+        return "workspace:*";
+    } catch {}
+  }
+  return `npm:@h-rig/${packageName}@${version}`;
+}
+function mutableDependencySections(manifest) {
+  return Object.fromEntries(DEPENDENCY_SECTION_NAMES.map((section) => [section, mutableDeps(manifest, section)]));
+}
+function discoveredConfigRigSpecs(projectRoot, sections, packageNames, version) {
+  const expected = {};
+  for (const section of DEPENDENCY_SECTION_NAMES) {
+    for (const name of Object.keys(sections[section])) {
+      const packageName = rigPackageName(name);
+      if (packageName && packageNames.has(packageName)) {
+        expected[name] = rigPackageSpec(projectRoot, packageName, version);
+      }
+    }
+  }
+  return expected;
+}
+function installedConfigDependencySpecs(sections, packageNames) {
+  const expected = {};
+  for (const section of INSTALL_CHECK_SECTION_NAMES) {
+    for (const [name, spec] of Object.entries(sections[section])) {
+      const packageName = rigPackageName(name);
+      if (packageName && packageNames.has(packageName) && typeof spec === "string")
+        expected[name] = spec;
+    }
+  }
+  return expected;
+}
+function hasFirstPartyRigDependency(manifest) {
+  const sections = mutableDependencySections(manifest);
+  return DEPENDENCY_SECTION_NAMES.some((section) => Object.keys(sections[section]).some((name) => rigPackageName(name) !== null));
+}
+function rigConfigImportPackageNames(projectRoot) {
+  const names = new Set;
+  for (const filename of RIG_CONFIG_FILENAMES) {
+    const path = join(projectRoot, filename);
+    if (!existsSync(path))
+      continue;
+    const source = readFileSync(path, "utf8");
+    const importPattern = /(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g;
+    for (const match of source.matchAll(importPattern)) {
+      const packageName = rigPackageNameFromSpecifier(match[1] ?? "");
+      if (packageName)
+        names.add(packageName);
+    }
+  }
+  return [...names];
+}
+function withRigConfigDeps(projectRoot, manifest, options) {
+  const configPackageNames = new Set(options.requiredConfigPackageNames);
+  const sections = mutableDependencySections(manifest);
+  let changed = false;
+  for (const [name, spec] of Object.entries(discoveredConfigRigSpecs(projectRoot, sections, configPackageNames, options.version))) {
+    for (const section of DEPENDENCY_SECTION_NAMES) {
+      if (!Object.prototype.hasOwnProperty.call(sections[section], name))
+        continue;
+      if (sections[section][name] !== spec) {
+        sections[section][name] = spec;
+        changed = true;
+      }
+    }
+  }
+  for (const packageName of options.requiredConfigPackageNames) {
+    const name = `@rig/${packageName}`;
+    const existsInInstallableSection = INSTALL_CHECK_SECTION_NAMES.some((section) => Object.prototype.hasOwnProperty.call(sections[section], name));
+    if (existsInInstallableSection)
+      continue;
+    sections.devDependencies[name] = rigPackageSpec(projectRoot, packageName, options.version);
+    changed = true;
+  }
+  const next = {
+    ...Object.keys(manifest).length > 0 ? manifest : { name: basename(projectRoot) || "rig-project", private: true }
+  };
+  for (const section of DEPENDENCY_SECTION_NAMES) {
+    if (Object.keys(sections[section]).length > 0)
+      next[section] = sections[section];
+  }
+  return { next, changed, expectedInstalled: installedConfigDependencySpecs(sections, configPackageNames) };
+}
+function expectedPublishedVersion(spec) {
+  const match = spec.match(/^npm:@h-rig\/[^@]+@(.+)$/);
+  if (!match)
+    return null;
+  return match[1] === "latest" ? null : match[1] ?? null;
+}
+function installedRigPackageHealthy(projectRoot, packageName, expectedSpec) {
+  const rigName = rigPackageName(packageName);
+  if (!rigName)
+    return true;
+  const manifest = readPackageManifest(join(projectRoot, "node_modules", "@rig", rigName, "package.json"));
+  if (!manifest)
+    return false;
+  const installedVersion = typeof manifest.version === "string" ? manifest.version.trim() : "";
+  const expectedVersion = expectedPublishedVersion(expectedSpec);
+  if (expectedVersion && installedVersion !== expectedVersion)
+    return false;
+  if (!installedVersion)
+    return false;
+  if (rigName === "core" || rigName === "standard-plugin") {
+    const exportsField = manifest.exports;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return false;
+    const exportsRecord = exportsField;
+    if (rigName === "core" && !("./config" in exportsRecord))
+      return false;
+    if (rigName === "standard-plugin" && !("./bundle" in exportsRecord))
+      return false;
+  }
+  return true;
+}
+function resolvePackageManagerBinary(manager) {
+  if (manager !== "bun")
+    return manager;
+  const candidates = [
+    Bun.which("bun") ?? "",
+    process.env.RIG_BUN_PATH?.trim() ?? "",
+    process.env.HOME ? join(process.env.HOME, ".bun", "bin", "bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate))
+      return candidate;
+  }
+  return "bun";
+}
+function installCommandFor(manifest) {
+  const packageManager = typeof manifest.packageManager === "string" ? manifest.packageManager.trim() : "";
+  const manager = packageManager.split("@")[0] || "bun";
+  switch (manager) {
+    case "npm":
+      return ["npm", "install", "--ignore-scripts"];
+    case "pnpm":
+      return ["pnpm", "install", "--ignore-scripts"];
+    case "yarn":
+      return ["yarn", "install", "--ignore-scripts"];
+    default:
+      return [resolvePackageManagerBinary("bun"), "install", "--ignore-scripts"];
+  }
+}
+function ensureRigConfigDependenciesInstalled(input) {
+  const root = resolve(input.projectRoot);
+  const version = resolveRigConfigPackageVersion(input);
+  const manifestPath = join(root, "package.json");
+  const current = readPackageManifest(manifestPath);
+  const hasConfig = hasRigConfig(root);
+  if (!hasConfig && (!current || !hasFirstPartyRigDependency(current))) {
+    return { rewroteManifest: false, ranInstall: false, command: null, version };
+  }
+  const requiredConfigPackageNames = hasConfig ? [...new Set([...REQUIRED_RIG_CONFIG_PACKAGE_NAMES, ...rigConfigImportPackageNames(root)])] : [];
+  const { next, changed, expectedInstalled } = withRigConfigDeps(root, current ?? {}, { requiredConfigPackageNames, version });
+  const installNeeded = changed || Object.entries(expectedInstalled).some(([name, spec]) => !installedRigPackageHealthy(root, name, spec));
+  if (changed) {
+    writeFileSync(manifestPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  }
+  if (!installNeeded) {
+    return { rewroteManifest: changed, ranInstall: false, command: null, version };
+  }
+  const command = installCommandFor(next);
+  const commandBin = command[0];
+  if (!commandBin)
+    throw new Error("install command resolved to an empty argv");
+  const result = spawnSync(commandBin, command.slice(1), {
+    cwd: root,
+    encoding: "utf8",
+    env: process.env
+  });
+  if (result.status !== 0) {
+    const detail = [
+      result.error ? String(result.error) : "",
+      `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
+    ].filter(Boolean).join(`
+`);
+    throw new Error(`Rig dependency preflight failed in ${root}: ${command.join(" ")}${detail ? `
+${detail}` : ""}
+Rig does not delete node_modules or lockfiles automatically; fix the repo/package-manager state explicitly if install recovery is needed.`.trim());
+  }
+  return { rewroteManifest: changed, ranInstall: true, command: command.join(" "), version };
+}
+// packages/init-lib/src/ensure-config.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { stringify as stringifyToml } from "smol-toml";
+import { getStandardPluginsResolver } from "@rig/core/embedded-plugins";
+function rigfigConfigPath(projectRoot) {
+  return resolve2(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(resolve2(projectRoot, ".rig"), { recursive: true });
+  const path = rigfigConfigPath(projectRoot);
+  writeFileSync2(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);
+}
+function ensureDeclarativeConfig(projectRoot, options = {}) {
+  const rigfig = rigfigConfigPath(projectRoot);
+  if (existsSync2(rigfig))
+    return { created: false, path: rigfig };
+  for (const codeConfig of ["rig.config.ts", "rig.config.mts", "rig.config.json"]) {
+    if (existsSync2(resolve2(projectRoot, codeConfig))) {
+      return { created: false, path: null, reason: `${codeConfig} present` };
+    }
+  }
+  const resolver = getStandardPluginsResolver();
+  if (!resolver) {
+    return { created: false, path: null, reason: "no embedded standard plugins registered (seed wiring error)" };
+  }
+  const context = options.repoSlug ? { projectRoot, repoSlug: options.repoSlug } : { projectRoot };
+  const composed = composeDeclarativeConfig(resolver(), context);
+  if (!isPlainObject(composed.taskSource)) {
+    return { created: false, path: null, reason: "no plugin produced a task source (no GitHub remote / explicit repo)" };
+  }
+  const path = writeRigfigConfig(projectRoot, composed);
+  return { created: true, path };
+}
+// packages/init-lib/src/setup.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, resolve as resolve3 } from "path";
+import {
+  createGitHubAuthStore,
+  probeGitHubRepository,
+  resolveGitHubAuthStatus,
+  saveGitHubTokenForProject
+} from "@rig/github-lib";
+import { addPlacement, selectPlacement } from "@rig/core/placement";
+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 ?? spawnSync2)(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 resolve3(projectRoot, ".rig", "state", "connection.json");
+}
+function projectLinkStatePath(projectRoot) {
+  return resolve3(projectRoot, ".rig", "state", "project-link.json");
+}
+function readJsonRecord(path) {
+  if (!existsSync3(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(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 });
+  writeFileSync3(path, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function ensureRigPrivateDirs(projectRoot) {
+  mkdirSync2(resolve3(projectRoot, ".rig", "state"), { recursive: true });
+  mkdirSync2(resolve3(projectRoot, ".rig", "logs"), { recursive: true });
+  mkdirSync2(resolve3(projectRoot, ".rig", "runs"), { recursive: true });
+  mkdirSync2(resolve3(projectRoot, ".rig", "tmp"), { recursive: true });
+  mkdirSync2(resolve3(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve3(projectRoot, ".rig", "task-config.json");
+  if (!existsSync3(taskConfigPath))
+    writeFileSync3(taskConfigPath, `{}
+`, "utf-8");
+}
+function ensureGitignoreEntries(projectRoot) {
+  const path = resolve3(projectRoot, ".gitignore");
+  const existing = existsSync3(path) ? readFileSync2(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 (!existsSync3(path))
+    return { exists: false, valid: false, path, slug: null, reason: "missing .rig/rigfig.toml" };
+  try {
+    const source = readFileSync2(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 = resolve3(projectRoot, ".rig", "state");
+  if (!existsSync3(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 = existsSync3(resolve3(projectRoot, "packages", "pi-rig", "package.json")) ? resolve3(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 {
+  writeRigfigConfig,
+  writeRigConnectionState,
+  writeRigConfig,
+  validateGitHubAuth,
+  saveGitHubTokenLocally,
+  runSetup,
+  rigfigConfigPath,
+  readRigConnectionStatus,
+  readRigConfigStatus,
+  readGhAuthToken,
+  parseRepoSlugFromRemote,
+  parseRepoSlug,
+  ensureRigPrivateDirs,
+  ensureRigConfigDependenciesInstalled,
+  ensurePiRigInstalledForSetup,
+  ensureGitignoreEntries,
+  ensureGitHubLabels,
+  ensureGitHubAuth,
+  ensureDeclarativeConfig,
+  detectStartupStatus,
+  detectRigStartupStatus,
+  detectOriginRepoSlug,
+  detectGhAuth,
+  composeDeclarativeConfig,
+  composeAndWriteRigfig,
+  applyRigSetupProject
+};