@h-rig/core 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/profile-ops.js

@@ -0,0 +1,252 @@
+// @bun
+// packages/core/src/profile-ops.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+
+// packages/core/src/harness-paths.ts
+import { resolve as resolve3 } from "path";
+
+// packages/core/src/layout.ts
+import { resolve as resolve2 } from "path";
+import {
+  RIG_ARTIFACTS_DIRNAME,
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// packages/core/src/checkout-root.ts
+import { dirname, resolve } from "path";
+import { existsSync } from "fs";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+
+// packages/core/src/layout.ts
+var resolveMonorepoRoot = resolveCheckoutRoot;
+function resolveRuntimeWorkspaceLayout(workspaceDir) {
+  const root = resolve2(workspaceDir);
+  const rigRoot = resolve2(root, ".rig");
+  const logsDir = resolve2(rigRoot, "logs");
+  const stateDir = resolve2(rigRoot, "state");
+  const runtimeDir = resolve2(rigRoot, "runtime");
+  const binDir = resolve2(rigRoot, "bin");
+  return {
+    workspaceDir: root,
+    rigRoot,
+    stateDir,
+    logsDir,
+    artifactsRoot: resolve2(root, RIG_ARTIFACTS_DIRNAME),
+    runtimeDir,
+    homeDir: resolve2(rigRoot, "home"),
+    tmpDir: resolve2(rigRoot, "tmp"),
+    cacheDir: resolve2(rigRoot, "cache"),
+    sessionDir: resolve2(rigRoot, "session"),
+    binDir,
+    distDir: resolve2(rigRoot, "dist"),
+    pluginBinDir: resolve2(binDir, "plugins"),
+    contextPath: resolve2(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve2(logsDir, "control-plane.events.jsonl")
+  };
+}
+function resolveActiveRuntimeWorkspaceRoot(_monorepoRoot) {
+  const explicit = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (!explicit) {
+    throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
+  }
+  return resolve2(explicit);
+}
+function resolveRigLayout(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const definitionRoot = resolve2(projectRoot, RIG_DEFINITION_DIRNAME);
+  const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
+  const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
+  const policyDir = resolve2(definitionRoot, "policy");
+  return {
+    projectRoot,
+    monorepoRoot,
+    definitionRoot,
+    runtimeWorkspaceRoot,
+    stateRoot: runtimeLayout.rigRoot,
+    artifactsRoot: runtimeLayout.artifactsRoot,
+    configPath: resolve2(definitionRoot, "config.sh"),
+    taskConfigPath: resolve2(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    policyDir,
+    policyFile: resolve2(policyDir, "policy.json"),
+    pluginsDir: resolve2(definitionRoot, "plugins"),
+    hooksDir: resolve2(definitionRoot, "hooks"),
+    toolsDir: resolve2(definitionRoot, "tools"),
+    templatesDir: resolve2(definitionRoot, "templates"),
+    validationDir: resolve2(definitionRoot, "validation"),
+    stateDir: runtimeLayout.stateDir,
+    logsDir: runtimeLayout.logsDir,
+    notificationsDir: resolve2(definitionRoot, "notifications"),
+    runtimeDir: runtimeLayout.runtimeDir,
+    distDir: runtimeLayout.distDir,
+    binDir: runtimeLayout.binDir,
+    pluginBinDir: runtimeLayout.pluginBinDir,
+    keybindingsPath: resolve2(definitionRoot, "keybindings.json"),
+    controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
+  };
+}
+
+// packages/core/src/harness-paths.ts
+function resolveHarnessPaths(projectRoot) {
+  const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const harnessRoot = resolve3(projectRoot, "rig");
+  const stateRoot = resolve3(projectRoot, ".rig");
+  const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
+  const stateDir = layout?.stateDir ?? resolve3(stateRoot, "state");
+  const logsDir = layout?.logsDir ?? resolve3(stateRoot, "logs");
+  const artifactsDir = layout?.artifactsRoot ?? resolve3(monorepoRoot, "artifacts");
+  const taskConfigPath = layout?.taskConfigPath ?? resolve3(monorepoRoot, ".rig", "task-config.json");
+  const binDir = layout?.binDir ?? resolve3(stateRoot, "bin");
+  return {
+    harnessRoot,
+    stateDir: process.env.RIG_STATE_DIR || stateDir,
+    artifactsDir,
+    logsDir: process.env.RIG_LOGS_DIR || logsDir,
+    binDir,
+    hooksDir: resolve3(harnessRoot, "hooks"),
+    validationDir: resolve3(harnessRoot, "validation"),
+    taskConfigPath,
+    sessionPath: process.env.RIG_SESSION_FILE || resolve3(stateRoot, "session", "session.json"),
+    monorepoRoot,
+    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve3(monorepoRoot, "TSAPITests"),
+    taskRepoCommitsPath: resolve3(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve3(stateDir, "base-repo-pins.json"),
+    failedApproachesPath: resolve3(stateDir, "failed_approaches.md"),
+    agentProfilePath: resolve3(stateDir, "agent-profile.json"),
+    reviewProfilePath: resolve3(stateDir, "review-profile.json")
+  };
+}
+
+// packages/core/src/profile-ops.ts
+var DEFAULTS = {
+  model: "pi",
+  runtime: "pi",
+  plugin: "pi",
+  reviewMode: parseEnvOrDefault(process.env.AI_REVIEW_MODE, ["off", "advisory", "required"], "advisory"),
+  reviewProvider: parseEnvOrDefault(process.env.AI_REVIEW_PROVIDER, ["greptile", "github"], "github")
+};
+function parseEnvOrDefault(value, allowed, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  return allowed.includes(value) ? value : fallback;
+}
+async function readProfileFile(path) {
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    return await Bun.file(path).json();
+  } catch {
+    return null;
+  }
+}
+async function showProfile(projectRoot, compact = false) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const profile = await loadProfile(paths.agentProfilePath);
+  if (compact) {
+    console.log(`model=${profile.model} runtime=${profile.runtime} plugin=${profile.agent_plugin}`);
+    return;
+  }
+  console.log("Execution Profile:");
+  console.log(`  model:        ${profile.model}`);
+  console.log(`  runtime:      ${profile.runtime}`);
+  console.log(`  plugin:       ${profile.agent_plugin}`);
+}
+async function setProfile(projectRoot, options) {
+  const invalid = [options.model, options.runtime, options.plugin, options.preset].filter((value) => typeof value === "string" && value.trim().length > 0 && value.trim() !== "pi");
+  if (invalid.length > 0) {
+    throw new Error("Only the Pi runtime profile is supported by this Rig substrate.");
+  }
+  const paths = resolveHarnessPaths(projectRoot);
+  mkdirSync(paths.stateDir, { recursive: true });
+  const next = {
+    model: "pi",
+    runtime: "pi",
+    agent_plugin: "pi",
+    updated_at: new Date().toISOString()
+  };
+  writeFileSync(paths.agentProfilePath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  await showProfile(projectRoot, false);
+}
+async function showReviewProfile(projectRoot) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const profile = await loadReviewProfile(paths.reviewProfilePath);
+  console.log("AI Review Profile:");
+  console.log(`  mode:      ${profile.mode}`);
+  console.log(`  provider:  ${profile.provider}`);
+  console.log(`  file:      ${paths.reviewProfilePath}`);
+}
+async function setReviewProfile(projectRoot, mode, provider) {
+  if (mode !== "off" && mode !== "advisory" && mode !== "required") {
+    throw new Error(`Invalid mode: ${mode}. Use off|advisory|required.`);
+  }
+  const resolvedProvider = provider || DEFAULTS.reviewProvider;
+  if (resolvedProvider !== "greptile" && resolvedProvider !== "github") {
+    throw new Error(`Invalid provider: ${resolvedProvider}. Supported: github|greptile.`);
+  }
+  const paths = resolveHarnessPaths(projectRoot);
+  mkdirSync(paths.stateDir, { recursive: true });
+  const next = {
+    mode,
+    provider: resolvedProvider,
+    updated_at: new Date().toISOString()
+  };
+  writeFileSync(paths.reviewProfilePath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  await showReviewProfile(projectRoot);
+}
+async function loadProfile(path) {
+  const parsed = await readProfileFile(path);
+  return {
+    model: "pi",
+    runtime: "pi",
+    agent_plugin: "pi",
+    updated_at: parsed?.updated_at || new Date().toISOString()
+  };
+}
+async function loadReviewProfile(path) {
+  const parsed = await readProfileFile(path);
+  if (parsed) {
+    return {
+      mode: parsed.mode || DEFAULTS.reviewMode,
+      provider: parsed.provider || DEFAULTS.reviewProvider,
+      updated_at: parsed.updated_at || new Date().toISOString()
+    };
+  }
+  return {
+    mode: DEFAULTS.reviewMode,
+    provider: DEFAULTS.reviewProvider,
+    updated_at: new Date().toISOString()
+  };
+}
+export {
+  showReviewProfile,
+  showProfile,
+  setReviewProfile,
+  setProfile
+};

package/dist/src/project-plugins.d.ts

@@ -0,0 +1,63 @@
+import type { RigConfig } from "@rig/contracts";
+import { type PluginHost } from "./plugin-host";
+import type { RigPlugin } from "./plugin-runtime";
+export type ProjectPluginResolutionMode = "strict-config-only";
+export type ProjectConfigPresence = {
+    readonly status: "loaded";
+    readonly path: string | null;
+} | {
+    readonly status: "missing";
+    readonly path: null;
+};
+export type ProjectPluginResolution = {
+    readonly mode: ProjectPluginResolutionMode;
+    readonly projectRoot: string;
+    readonly configPresence: ProjectConfigPresence;
+    readonly config: RigConfig | null;
+    readonly plugins: readonly RigPlugin[];
+};
+export type ProjectPluginHostResult = {
+    readonly host: PluginHost;
+    readonly resolved: ProjectPluginResolution;
+};
+export type LoadProjectConfig = (projectRoot: string) => Promise<RigConfig>;
+export type LoadProjectPluginSetOptions = {
+    readonly mode?: ProjectPluginResolutionMode;
+    readonly load?: LoadProjectConfig;
+};
+export type ProjectPluginResolutionOptions = Omit<LoadProjectPluginSetOptions, "mode"> & {
+    readonly projectRoot: string;
+    readonly mode: ProjectPluginResolutionMode;
+};
+export declare function loadProjectPluginSet(options: ProjectPluginResolutionOptions): Promise<ProjectPluginResolution>;
+export declare function loadProjectPluginSet(projectRoot: string, options?: LoadProjectPluginSetOptions): Promise<ProjectPluginResolution>;
+export type ResolvedPluginHost = {
+    readonly host: PluginHost;
+    readonly config: RigConfig;
+};
+export type ResolvePluginHostOptions = {
+    readonly load?: LoadProjectConfig;
+};
+/**
+ * The single cached plugin-host resolver. Returns the resolved host plus the
+ * loaded config for a project root, memoized per normalized root and validated
+ * by the rig.config file mtime — an edited config rebuilds the host (preserving
+ * loadConfig's mtime-cache semantics) while every other consumer in the same
+ * generation shares one resolved host.
+ *
+ * It propagates loadConfig's throw on a missing/broken config; each consumer
+ * keeps its own try/catch so per-call-site degradation (graceful-null vs
+ * surfaced error) is unchanged. A custom `load` bypasses the shared cache so it
+ * cannot poison the canonical on-disk host other consumers read.
+ */
+export declare function resolvePluginHost(projectRoot: string, options?: ResolvePluginHostOptions): Promise<ResolvedPluginHost>;
+/**
+ * Resolve the plugin host for a project root, returning the host plus the full
+ * resolution shape. This delegates to the single cached `resolvePluginHost`
+ * memo so every consumer in a process SHARES one resolved host for a root
+ * instead of re-evaluating rig.config.ts and constructing an independent host
+ * (architecture-reference §18: one resolved host per process/root). Graceful
+ * missing-config degradation and the custom-`load` bypass are preserved.
+ */
+export declare function createProjectPluginHost(options: ProjectPluginResolutionOptions): Promise<ProjectPluginHostResult>;
+export declare function createProjectPluginHost(projectRoot: string, options?: LoadProjectPluginSetOptions): Promise<ProjectPluginHostResult>;