@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/materialize-task-config.js

@@ -0,0 +1,453 @@
+// @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/runtime/src/control-plane/task-source.ts
+function createTaskSourceRegistry() {
+  const byId = new Map;
+  const order = [];
+  return {
+    register(s) {
+      if (byId.has(s.id))
+        throw new Error(`task source already registered: ${s.id}`);
+      byId.set(s.id, s);
+      order.push(s);
+    },
+    resolveById(id) {
+      const s = byId.get(id);
+      if (!s)
+        throw new Error(`task source not registered: ${id}`);
+      return s;
+    },
+    resolveByKind(kind) {
+      for (const s of order)
+        if (s.kind === kind)
+          return s;
+      throw new Error(`no task source registered for kind: ${kind}`);
+    },
+    list: () => order
+  };
+}
+
+// packages/runtime/src/control-plane/task-source-bootstrap.ts
+function formatRegisteredKinds(pluginHost) {
+  const kinds = pluginHost ? pluginHost.listExecutableTaskSources().map((source) => source.kind) : [];
+  return kinds.length > 0 ? kinds.join(", ") : "none";
+}
+function buildTaskSourceRegistry(config, pluginHost) {
+  const registry = createTaskSourceRegistry();
+  const taskSourceConfig = config.taskSource;
+  const factory = pluginHost?.resolveTaskSourceFactoryByKind(taskSourceConfig.kind);
+  if (!factory) {
+    throw new Error(`No task source factory registered for kind "${taskSourceConfig.kind}". ` + `Registered kinds: ${formatRegisteredKinds(pluginHost)}. ` + "Load a plugin that contributes an executable task source factory for this kind.");
+  }
+  registry.register(factory.factory(taskSourceConfig));
+  return registry;
+}
+var init_task_source_bootstrap = () => {};
+
+// packages/runtime/src/control-plane/repos/registry.ts
+function createRepoRegistry(entries) {
+  const map = new Map;
+  for (const e of entries) {
+    if (map.has(e.id))
+      throw new Error(`repo already registered: ${e.id}`);
+    map.set(e.id, { ...e });
+  }
+  const ordered = Array.from(map.values());
+  return {
+    getById: (id) => map.get(id),
+    list: () => ordered
+  };
+}
+function setManagedRepos(entries) {
+  const next = new Map;
+  for (const e of entries) {
+    if (next.has(e.id)) {
+      throw new Error(`managed repo already registered: ${e.id}`);
+    }
+    next.set(e.id, e);
+  }
+  MANAGED_REPOS = next;
+}
+function repoRegistrationToManagedEntry(reg) {
+  if (!reg.defaultBranch) {
+    return null;
+  }
+  return {
+    id: reg.id,
+    alias: reg.defaultPath ?? reg.id,
+    defaultBranch: reg.defaultBranch,
+    defaultRemoteUrl: reg.url,
+    remoteEnvVar: reg.remoteEnvVar,
+    checkoutEnvVar: reg.checkoutEnvVar
+  };
+}
+var MANAGED_REPOS;
+var init_registry = __esm(() => {
+  MANAGED_REPOS = new Map;
+});
+
+// packages/runtime/src/control-plane/agent-roles.ts
+function createAgentRoleRegistry(pluginRoles, configOverrides) {
+  const map = new Map;
+  for (const r of pluginRoles) {
+    if (map.has(r.id))
+      throw new Error(`agent role already registered: ${r.id}`);
+    const override = configOverrides?.[r.id];
+    const model = override?.model ?? r.defaultModel;
+    if (!model) {
+      throw new Error(`agent role "${r.id}" has no model \u2014 provide defaultModel in plugin or model in config.runtime.agentRoles.${r.id}`);
+    }
+    map.set(r.id, { ...r, model });
+  }
+  return {
+    resolve(id) {
+      const r = map.get(id);
+      if (!r)
+        throw new Error(`agent role not registered: ${id}`);
+      return r;
+    },
+    list: () => Array.from(map.values())
+  };
+}
+
+// packages/runtime/src/control-plane/task-fields.ts
+function createTaskFieldRegistry(extensions) {
+  const byId = new Map;
+  for (const e of extensions) {
+    if (byId.has(e.id))
+      throw new Error(`task field extension already registered: ${e.id}`);
+    byId.set(e.id, e);
+  }
+  return {
+    get: (id) => byId.get(id),
+    list: () => Array.from(byId.values()),
+    fieldNames: () => Array.from(byId.values()).map((e) => e.fieldName),
+    validateTaskFields(task) {
+      const errors = [];
+      for (const ext of byId.values()) {
+        let schema;
+        try {
+          schema = JSON.parse(ext.schemaJson);
+        } catch {
+          errors.push(`task field "${ext.id}": schemaJson is not valid JSON`);
+          continue;
+        }
+        const isRequired = typeof schema === "object" && schema !== null && schema.required === true;
+        if (!isRequired)
+          continue;
+        const value = task[ext.fieldName];
+        if (value === undefined || value === null || value === "") {
+          errors.push(`task field "${ext.fieldName}" (from extension "${ext.id}") is required but missing`);
+        }
+      }
+      return errors.length === 0 ? { ok: true } : { ok: false, errors };
+    }
+  };
+}
+
+// packages/runtime/src/control-plane/validators/runtime-registration.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function createValidatorRegistry() {
+  const map = new Map;
+  const order = [];
+  const registry = {
+    register(v) {
+      if (map.has(v.id))
+        throw new Error(`validator already registered: ${v.id}`);
+      map.set(v.id, v);
+      order.push(v);
+    },
+    resolve(id) {
+      const v = map.get(id);
+      if (!v)
+        throw new Error(`validator not registered: ${id}`);
+      return v;
+    },
+    list: () => order
+  };
+  registerBuiltInValidators(registry);
+  return registry;
+}
+function registerBuiltInValidators(registry) {
+  registry.register({
+    id: "std:typecheck",
+    category: "custom",
+    description: "Runs the package typecheck script when present.",
+    run: async (ctx) => runStdTypecheck(ctx)
+  });
+}
+async function runStdTypecheck(ctx) {
+  const packageJsonPath = join(ctx.workspaceRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return {
+      id: "std:typecheck",
+      passed: false,
+      summary: `package.json not found at ${packageJsonPath}`
+    };
+  }
+  const proc = Bun.spawn(["bun", "run", "typecheck"], {
+    cwd: ctx.workspaceRoot,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const output = `${stdout}${stderr}`.trim();
+  return {
+    id: "std:typecheck",
+    passed: exitCode === 0,
+    summary: exitCode === 0 ? "typecheck passed" : "typecheck failed",
+    ...output ? { details: output.slice(0, 4000) } : {}
+  };
+}
+var init_runtime_registration = () => {};
+
+// packages/runtime/src/control-plane/native/scope-rules.ts
+function setScopeRules(rules) {
+  activeRules = rules ?? null;
+}
+var activeRules = null;
+
+// packages/runtime/src/control-plane/hook-materializer.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+function matcherToString(matcher) {
+  if (matcher.kind === "all")
+    return;
+  if (matcher.kind === "tool")
+    return matcher.name;
+  return matcher.pattern;
+}
+function isPluginOwned(cmd) {
+  return typeof cmd[MARKER_PLUGIN] === "string";
+}
+function materializeHooks(projectRoot, entries) {
+  const settingsPath = resolve(projectRoot, ".claude", "settings.json");
+  const existing = existsSync2(settingsPath) ? safeReadJson(settingsPath) : {};
+  const hooks = existing.hooks ?? {};
+  for (const event of Object.keys(hooks)) {
+    const groups = hooks[event] ?? [];
+    const cleaned = [];
+    for (const group of groups) {
+      const operatorHooks = group.hooks.filter((h) => !isPluginOwned(h));
+      if (operatorHooks.length > 0) {
+        cleaned.push({ ...group, hooks: operatorHooks });
+      }
+    }
+    if (cleaned.length > 0) {
+      hooks[event] = cleaned;
+    } else {
+      delete hooks[event];
+    }
+  }
+  for (const { pluginName, hook } of entries) {
+    if (!hook.command) {
+      continue;
+    }
+    const event = hook.event;
+    const matcherString = matcherToString(hook.matcher);
+    const groups = hooks[event] ??= [];
+    let group = groups.find((g) => g.matcher === matcherString);
+    if (!group) {
+      group = matcherString === undefined ? { hooks: [] } : { matcher: matcherString, hooks: [] };
+      groups.push(group);
+    }
+    group.hooks.push({
+      type: "command",
+      command: hook.command,
+      [MARKER_PLUGIN]: pluginName,
+      [MARKER_HOOK_ID]: hook.id
+    });
+  }
+  const next = { ...existing };
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  return settingsPath;
+}
+function safeReadJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var MARKER_PLUGIN = "_rigPlugin", MARKER_HOOK_ID = "_rigHookId";
+var init_hook_materializer = () => {};
+
+// packages/runtime/src/control-plane/plugin-host-context.ts
+var exports_plugin_host_context = {};
+__export(exports_plugin_host_context, {
+  buildPluginHostContext: () => buildPluginHostContext
+});
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+async function buildPluginHostContext(projectRoot) {
+  let config;
+  try {
+    config = await loadConfig(projectRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("no rig.config")) {
+      return null;
+    }
+    throw err;
+  }
+  const pluginHost = createPluginHost(config.plugins);
+  setScopeRules(config.workspace.scopeNormalization);
+  const validatorRegistry = createValidatorRegistry();
+  for (const impl of pluginHost.listExecutableValidators()) {
+    validatorRegistry.register(impl);
+  }
+  const taskSourceRegistry = buildTaskSourceRegistry(config, pluginHost);
+  const repoRegistry = createRepoRegistry(pluginHost.listRepoSources());
+  const managedEntries = pluginHost.listRepoSources().map(repoRegistrationToManagedEntry).filter((e) => e !== null);
+  setManagedRepos(managedEntries);
+  const configRoleOverrides = config.runtime?.agentRoles;
+  const agentRoleRegistry = createAgentRoleRegistry(pluginHost.listAgentRoles(), configRoleOverrides);
+  const taskFieldRegistry = createTaskFieldRegistry(pluginHost.listTaskFieldExtensions());
+  try {
+    const hookEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.hooks ?? []).map((hook) => ({
+      pluginName: plugin.name,
+      hook
+    })));
+    if (hookEntries.length > 0) {
+      materializeHooks(projectRoot, hookEntries);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
+  return {
+    config,
+    pluginHost,
+    validatorRegistry,
+    taskSourceRegistry,
+    repoRegistry,
+    agentRoleRegistry,
+    taskFieldRegistry
+  };
+}
+var init_plugin_host_context = __esm(() => {
+  init_task_source_bootstrap();
+  init_registry();
+  init_runtime_registration();
+  init_hook_materializer();
+});
+
+// packages/runtime/src/control-plane/materialize-task-config.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+async function materializePluginHostTaskConfig(projectRoot) {
+  const hasConfig = existsSync3(resolve2(projectRoot, "rig.config.ts")) || existsSync3(resolve2(projectRoot, "rig.config.json"));
+  if (!hasConfig)
+    return null;
+  const { buildPluginHostContext: buildPluginHostContext2 } = await Promise.resolve().then(() => (init_plugin_host_context(), exports_plugin_host_context));
+  let ctx;
+  try {
+    ctx = await buildPluginHostContext2(projectRoot);
+  } catch (err) {
+    console.warn(`[materialize-task-config] plugin host build failed (treating as legacy path): ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  if (!ctx)
+    return null;
+  const sources = ctx.taskSourceRegistry.list();
+  if (sources.length === 0)
+    return null;
+  const source = sources[0];
+  const tasks = await source.list();
+  if (tasks.length === 0)
+    return null;
+  const configPath = resolve2(projectRoot, ".rig", "task-config.json");
+  const existing = existsSync3(configPath) ? safeJsonRead(configPath) : {};
+  const merged = { ...existing };
+  let syncedCount = 0;
+  for (const task of tasks) {
+    const t = task;
+    const id = typeof t.id === "string" ? t.id.trim() : "";
+    if (!id)
+      continue;
+    const existingEntry = merged[id];
+    const existingIsOperatorEdit = existingEntry !== undefined && typeof existingEntry === "object" && existingEntry !== null && existingEntry.auto_synced !== true;
+    if (existingIsOperatorEdit) {
+      continue;
+    }
+    merged[id] = synthesizeEntry(t, ctx.config.taskSource);
+    syncedCount += 1;
+  }
+  mkdirSync2(dirname2(configPath), { recursive: true });
+  writeFileSync2(configPath, `${JSON.stringify(merged, null, 2)}
+`, "utf-8");
+  return { configPath, syncedCount };
+}
+function synthesizeEntry(t, taskSource) {
+  const role = typeof t.role === "string" ? t.role : undefined;
+  const scope = Array.isArray(t.scope) ? t.scope.filter((s) => typeof s === "string") : [];
+  const validation = Array.isArray(t.validators) ? t.validators.filter((v) => typeof v === "string") : Array.isArray(t.validation) ? t.validation.filter((v) => typeof v === "string") : [];
+  const description = typeof t.description === "string" ? t.description : typeof t.body === "string" ? t.body : undefined;
+  const acceptance = typeof t.acceptanceCriteria === "string" ? t.acceptanceCriteria : undefined;
+  const title = typeof t.title === "string" ? t.title : undefined;
+  const status = typeof t.status === "string" ? t.status : undefined;
+  const sourceIssueId = typeof t.sourceIssueId === "string" ? t.sourceIssueId : taskSource.kind === "github-issues" && taskSource.owner && taskSource.repo ? `${taskSource.owner}/${taskSource.repo}#${String(t.id)}` : undefined;
+  return {
+    auto_synced: true,
+    _rig: {
+      taskSource: materializedTaskSource(taskSource),
+      ...sourceIssueId ? { sourceIssueId } : {}
+    },
+    ...title ? { title } : {},
+    ...status ? { status } : {},
+    ...sourceIssueId ? { sourceIssueId } : {},
+    ...role ? { role } : {},
+    scope,
+    validation,
+    ...description ? { description } : {},
+    ...acceptance ? { acceptance_criteria: acceptance } : {}
+  };
+}
+function materializedTaskSource(taskSource) {
+  return {
+    kind: taskSource.kind,
+    ...taskSource.path ? { path: taskSource.path } : {},
+    ...taskSource.owner ? { owner: taskSource.owner } : {},
+    ...taskSource.repo ? { repo: taskSource.repo } : {},
+    ...taskSource.labels ? { labels: taskSource.labels } : {},
+    ...taskSource.state ? { state: taskSource.state } : {}
+  };
+}
+function safeJsonRead(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+export {
+  materializePluginHostTaskConfig
+};