@h-rig/init-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./rig-init-builder";
-export * from "./setup";
+export * from "@rig/init-lib";
 export * from "./plugin";

package/dist/src/index.js

@@ -1,498 +1,43 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// packages/init-plugin/src/rig-init-builder.ts
-function buildRigInitConfigSource(input) {
-  const lines = [`import { defineConfig } from "@rig/core/config";`];
-  if (input.useStandardPlugin) {
-    lines.push(`import { standardPlugins } from "@rig/standard-plugin/bundle";`);
-    if (input.taskSource.kind === "github-issues") {
-      lines.push(`import { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
-    }
-  }
-  lines.push(``, `export default defineConfig({`);
-  const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
-  lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
-  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [...standardPlugins({`);
-    lines.push(`    taskSources: {`);
-    lines.push(`      githubCredentialProvider: createStateGitHubCredentialProvider(),`);
-    lines.push(`      githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
-    lines.push(`      githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
-    lines.push(`    },`);
-    lines.push(`  })],`);
-  } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardPlugins()" : ""}],`);
-  }
-  if (input.taskSource.kind === "github-issues") {
-    lines.push(`  taskSource: {`);
-    lines.push(`    kind: "github-issues",`);
-    lines.push(`    owner: ${JSON.stringify(input.taskSource.owner)},`);
-    lines.push(`    repo: ${JSON.stringify(input.taskSource.repo)},`);
-    lines.push(`    // labels: ["task"],  // uncomment to filter by labels`);
-    lines.push(`    state: "open",`);
-    if (input.taskSource.assignee?.trim()) {
-      lines.push(`    options: { assignee: ${JSON.stringify(input.taskSource.assignee.trim())} },`);
-    }
-    lines.push(`  },`);
-  } else {
-    lines.push(`  taskSource: {`);
-    lines.push(`    kind: "files",`);
-    lines.push(`    path: ${JSON.stringify(input.taskSource.path)},`);
-    lines.push(`  },`);
-  }
-  lines.push(`  workspace: { mainRepo: ".", isolation: "worktree" },`);
-  const sshTarget = input.sshTarget?.trim();
-  lines.push(sshTarget ? `  runtime: { harness: "pi", mode: "yolo", server: { sshTarget: ${JSON.stringify(sshTarget)} } },` : `  runtime: { harness: "pi", mode: "yolo" },  // server.sshTarget unset = local placement`);
-  lines.push(`  planning: { mode: "auto" },`);
-  lines.push(`  github: {`);
-  lines.push(`    issueUpdates: "lifecycle",`);
-  lines.push(`    projects: { enabled: false },`);
-  lines.push(`  },`);
-  lines.push(`  automation: { maxValidationAttempts: 30, maxPrFixIterations: 100500 },`);
-  lines.push(`  pr: { mode: "auto", watchChecks: true, autoFixChecks: true, autoFixReview: true },`);
-  lines.push(`  merge: { mode: "auto", method: "repo-default", deleteBranch: "repo-default", bypass: false },`);
-  lines.push(`  issueAnalysis: { enabled: true, harness: "pi", mode: "continuous" },`);
-  lines.push(`});`);
-  lines.push(``);
-  return lines.join(`
-`);
-}
-
-// packages/init-plugin/src/setup.ts
-var exports_setup = {};
-__export(exports_setup, {
-  writeRigConnectionState: () => writeRigConnectionState,
-  writeRigConfig: () => writeRigConfig,
-  validateGitHubAuth: () => validateGitHubAuth,
-  saveGitHubTokenLocally: () => saveGitHubTokenLocally,
-  runSetup: () => runSetup,
-  readRigConnectionStatus: () => readRigConnectionStatus,
-  readRigConfigStatus: () => readRigConfigStatus,
-  readGhAuthToken: () => readGhAuthToken,
-  parseRepoSlugFromRemote: () => parseRepoSlugFromRemote,
-  parseRepoSlug: () => parseRepoSlug,
-  ensureRigPrivateDirs: () => ensureRigPrivateDirs,
-  ensurePiRigInstalledForSetup: () => ensurePiRigInstalledForSetup,
-  ensureGitignoreEntries: () => ensureGitignoreEntries,
-  ensureGitHubLabels: () => ensureGitHubLabels,
-  ensureGitHubAuth: () => ensureGitHubAuth,
-  detectStartupStatus: () => detectStartupStatus,
-  detectRigStartupStatus: () => detectRigStartupStatus,
-  detectOriginRepoSlug: () => detectOriginRepoSlug,
-  detectGhAuth: () => detectGhAuth,
-  applyRigSetupProject: () => applyRigSetupProject
-});
-import { spawnSync } from "child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-import {
-  createGitHubAuthStore,
-  probeGitHubRepository,
-  resolveGitHubAuthStatus,
-  saveGitHubTokenForProject
-} from "@rig/github-provider-plugin";
-import { addPlacement, selectPlacement } from "@rig/runtime/control-plane/placement";
-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 resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function projectLinkStatePath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "project-link.json");
-}
-function readJsonRecord(path) {
-  if (!existsSync(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) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf-8");
-}
-function ensureRigPrivateDirs(projectRoot) {
-  mkdirSync(resolve(projectRoot, ".rig", "state"), { recursive: true });
-  mkdirSync(resolve(projectRoot, ".rig", "logs"), { recursive: true });
-  mkdirSync(resolve(projectRoot, ".rig", "runs"), { recursive: true });
-  mkdirSync(resolve(projectRoot, ".rig", "tmp"), { recursive: true });
-  mkdirSync(resolve(projectRoot, "artifacts"), { recursive: true });
-  const taskConfigPath = resolve(projectRoot, ".rig", "task-config.json");
-  if (!existsSync(taskConfigPath))
-    writeFileSync(taskConfigPath, `{}
-`, "utf-8");
-}
-function ensureGitignoreEntries(projectRoot) {
-  const path = resolve(projectRoot, ".gitignore");
-  const existing = existsSync(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) {
-  const repo = parseRepoSlug(slug);
-  writeFileSync(resolve(projectRoot, "rig.config.ts"), buildRigInitConfigSource({
-    projectName: repo.slug,
-    projectRepo: repo.slug,
-    taskSource: { kind: "github-issues", owner: repo.owner, repo: repo.repo },
-    useStandardPlugin: true
-  }), "utf-8");
-}
-function readRigConfigStatus(projectRoot) {
-  const path = resolve(projectRoot, "rig.config.ts");
-  if (!existsSync(path))
-    return { exists: false, valid: false, path, slug: null, reason: "missing rig.config.ts" };
-  try {
-    const source = readFileSync(path, "utf-8");
-    const owner = source.match(/\bowner:\s*["']([^"']+)["']/)?.[1] ?? null;
-    const repoValues = [...source.matchAll(/\brepo:\s*["']([^"']+)["']/g)].map((match) => match[1]).filter(Boolean);
-    const taskRepo = repoValues.find((value) => !value.includes("/")) ?? null;
-    const projectRepo = repoValues.find((value) => value.includes("/")) ?? null;
-    const githubIssues = /\bkind:\s*["']github-issues["']/.test(source);
-    const slug = owner && taskRepo ? `${owner}/${taskRepo}` : projectRepo;
-    if (!githubIssues || !slug)
-      return { exists: true, valid: false, path, slug: slug ?? null, reason: "rig.config.ts 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 = resolve(projectRoot, ".rig", "state");
-  if (!existsSync(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 = existsSync(resolve(projectRoot, "packages", "pi-rig", "package.json")) ? resolve(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 };
-}
-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, port: input.placement.port, 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 };
-}
-var RIG_LABELS_TO_ENSURE, RIG_LABEL_METADATA, detectStartupStatus;
-var init_setup = __esm(() => {
-  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"
-  ];
-  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." }
-  };
-  detectStartupStatus = detectRigStartupStatus;
-});
-
 // packages/init-plugin/src/index.ts
-init_setup();
+export * from "@rig/init-lib";
 
 // packages/init-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core/config";
+import { defineCapability } from "@rig/core/capability";
+import { DEPENDENCY_PREFLIGHT_CAPABILITY, PROJECT_SETUP, WORKSPACE_CONFIG_ENSURE } from "@rig/contracts";
+import { ensureDeclarativeConfig, ensureRigConfigDependenciesInstalled, runSetup } from "@rig/init-lib";
 var INIT_PLUGIN_NAME = "@rig/init-plugin";
-var SETUP_CAPABILITY_ID = "workspace.setup";
+var ProjectSetupCap = defineCapability(PROJECT_SETUP);
+var DependencyPreflightCap = defineCapability(DEPENDENCY_PREFLIGHT_CAPABILITY);
+var WorkspaceConfigEnsureCap = defineCapability(WORKSPACE_CONFIG_ENSURE);
+var setupService = {
+  async runSetup(input) {
+    const kind = input.placement.kind === "remote" ? "remote" : "local";
+    return runSetup({ ...input, placement: { ...input.placement, kind } });
+  }
+};
 var initPlugin = definePlugin({
   name: INIT_PLUGIN_NAME,
   version: "0.0.0-alpha.1",
   contributes: {
     capabilities: [
-      {
-        id: SETUP_CAPABILITY_ID,
+      ProjectSetupCap.provide(() => setupService, {
         title: "Project setup",
-        description: "Scaffold rig.config.ts, ensure rig:* labels, install the Pi/OMP extension, and verify GitHub auth.",
-        run: async (input) => (await Promise.resolve().then(() => (init_setup(), exports_setup))).runSetup(input)
-      }
+        description: "Scaffold rig.config.ts, ensure rig:* labels, install the Pi/OMP extension, and verify GitHub auth."
+      }),
+      DependencyPreflightCap.provide(async () => {
+        return { ensureInstalled: ensureRigConfigDependenciesInstalled };
+      }, {
+        title: "Rig config dependency preflight",
+        description: "Pin a project's @rig/* config dependencies and run the package manager's install so a user-authored rig.config.ts can be evaluated."
+      }),
+      WorkspaceConfigEnsureCap.provide(async () => {
+        return { ensureDeclarativeConfig: ({ projectRoot, repoSlug }) => ensureDeclarativeConfig(projectRoot, repoSlug ? { repoSlug } : {}) };
+      }, {
+        title: "Rig declarative config ensure",
+        description: "Autocreate the embedded declarative .rig/rigfig.toml config from the standard plugin defaults when a project has none."
+      })
     ]
   }
 });
@@ -500,29 +45,7 @@ function createInitPlugin() {
   return initPlugin;
 }
 export {
-  writeRigConnectionState,
-  writeRigConfig,
-  validateGitHubAuth,
-  saveGitHubTokenLocally,
-  runSetup,
-  readRigConnectionStatus,
-  readRigConfigStatus,
-  readGhAuthToken,
-  parseRepoSlugFromRemote,
-  parseRepoSlug,
   initPlugin,
-  ensureRigPrivateDirs,
-  ensurePiRigInstalledForSetup,
-  ensureGitignoreEntries,
-  ensureGitHubLabels,
-  ensureGitHubAuth,
-  detectStartupStatus,
-  detectRigStartupStatus,
-  detectOriginRepoSlug,
-  detectGhAuth,
   createInitPlugin,
-  buildRigInitConfigSource,
-  applyRigSetupProject,
-  SETUP_CAPABILITY_ID,
   INIT_PLUGIN_NAME
 };

package/dist/src/plugin.d.ts

@@ -1,5 +1,4 @@
 export declare const INIT_PLUGIN_NAME = "@rig/init-plugin";
-export declare const SETUP_CAPABILITY_ID = "workspace.setup";
-export declare const initPlugin: import("@rig/core").RigPlugin;
-export declare function createInitPlugin(): import("@rig/core").RigPlugin;
+export declare const initPlugin: import("@rig/core/config").RigPlugin;
+export declare function createInitPlugin(): import("@rig/core/config").RigPlugin;
 export default initPlugin;