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

package/README.md

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

package/dist/src/dependency-preflight.d.ts

@@ -0,0 +1,3 @@
+import type { RigConfigDependencyPreflightInput, RigConfigDependencyPreflightResult } from "@rig/contracts";
+/** Implements `RigConfigDependencyPreflightService["ensureInstalled"]`. */
+export declare function ensureRigConfigDependenciesInstalled(input: RigConfigDependencyPreflightInput): RigConfigDependencyPreflightResult;

package/dist/src/dependency-preflight.js

@@ -0,0 +1,229 @@
+// @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 };
+}
+export {
+  ensureRigConfigDependenciesInstalled
+};

package/dist/src/ensure-config.d.ts

@@ -0,0 +1,44 @@
+import type { ConfigDefaultsContext, RigPlugin } from "@rig/core/config";
+/** Absolute path to a project's declarative config. */
+export declare function rigfigConfigPath(projectRoot: string): string;
+/**
+ * Compose the declarative config from a plugin collection's contributed
+ * defaults, in plugin order (later plugins win on conflict).
+ */
+export declare function composeDeclarativeConfig(plugins: readonly RigPlugin[], context: ConfigDefaultsContext): Record<string, unknown>;
+/** THE single config writer: serialize a composed config object to `.rig/rigfig.toml`. */
+export declare function writeRigfigConfig(projectRoot: string, config: Record<string, unknown>): string;
+/**
+ * Compose the declarative config from the embedded standard plugins (threading
+ * an explicit `repoSlug` when the caller has one) and write `.rig/rigfig.toml`.
+ *
+ * This is the SINGLE entry the init wizard / setup flows use to materialize a
+ * config: it asks the embedded plugins for their fragments (the seed/composer
+ * holds no per-domain knowledge), applies the caller's wizard-choice `overlay`
+ * (deep-merged; later wins), and serializes via the one writer
+ * (`writeRigfigConfig`). When the overlay supplies a `taskSource`, it REPLACES
+ * the composed one wholesale (a kind switch — e.g. github-issues → files — must
+ * not leave stale owner/repo keys behind).
+ */
+export declare function composeAndWriteRigfig(projectRoot: string, options?: {
+    readonly repoSlug?: string;
+    readonly overlay?: Record<string, unknown>;
+}): string;
+export interface EnsureDeclarativeConfigResult {
+    /** True when this call wrote a new `.rig/rigfig.toml`. */
+    readonly created: boolean;
+    /** The rigfig path when one now exists (created or pre-existing), else null. */
+    readonly path: string | null;
+    /** Why nothing was created (code config present, no plugin produced a config, …). */
+    readonly reason?: string;
+}
+/**
+ * Ensure a project has a config, autocreating `.rig/rigfig.toml` from the
+ * embedded plugins' composed defaults when it has none. A pre-existing
+ * rig.config.ts (the power path) or rigfig.toml short-circuits. `repoSlug`, when
+ * supplied (init wizard / setup), is threaded to plugins that need the repo
+ * identity instead of having them derive it.
+ */
+export declare function ensureDeclarativeConfig(projectRoot: string, options?: {
+    readonly repoSlug?: string;
+}): EnsureDeclarativeConfigResult;

package/dist/src/ensure-config.js

@@ -0,0 +1,88 @@
+// @bun
+// 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);
+}
+function ensureDeclarativeConfig(projectRoot, options = {}) {
+  const rigfig = rigfigConfigPath(projectRoot);
+  if (existsSync(rigfig))
+    return { created: false, path: rigfig };
+  for (const codeConfig of ["rig.config.ts", "rig.config.mts", "rig.config.json"]) {
+    if (existsSync(resolve(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 };
+}
+export {
+  writeRigfigConfig,
+  rigfigConfigPath,
+  ensureDeclarativeConfig,
+  composeDeclarativeConfig,
+  composeAndWriteRigfig
+};

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./dependency-preflight";
+export * from "./ensure-config";
+export * from "./setup";