@h-rig/init-plugin 0.0.6-alpha.156

package/README.md

@@ -0,0 +1 @@
+# @h-rig/init-plugin

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,528 @@
+// @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();
+
+// packages/init-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core/config";
+var INIT_PLUGIN_NAME = "@rig/init-plugin";
+var SETUP_CAPABILITY_ID = "workspace.setup";
+var initPlugin = definePlugin({
+  name: INIT_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  contributes: {
+    capabilities: [
+      {
+        id: SETUP_CAPABILITY_ID,
+        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)
+      }
+    ]
+  }
+});
+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

@@ -0,0 +1,5 @@
+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 default initPlugin;