@h-rig/core 0.0.0-e2e-live.20260630085347

package/dist/src/index.js

@@ -0,0 +1,327 @@
+// @bun
+// packages/core/src/define-plugin.ts
+import { Schema } from "effect";
+import { RigPlugin as RigPluginManifest } from "@rig/contracts";
+function definePlugin(plugin) {
+  Schema.decodeUnknownSync(RigPluginManifest)(plugin);
+  return plugin;
+}
+// packages/core/src/define-config.ts
+import { Schema as Schema2 } from "effect";
+import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+function defineConfig(cfg) {
+  const withDefaults = applyConfigDefaults(cfg);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+// packages/core/src/plugin-host.ts
+function indexById(contributions, kind) {
+  const map = new Map;
+  const registrant = new Map;
+  for (const { item, pluginName } of contributions) {
+    if (map.has(item.id)) {
+      throw new Error(`duplicate ${kind} id "${item.id}": registered by plugins "${registrant.get(item.id)}" and "${pluginName}"`);
+    }
+    map.set(item.id, item);
+    registrant.set(item.id, pluginName);
+  }
+  return map;
+}
+function assertUniquePluginNames(plugins) {
+  const seen = new Set;
+  for (const plugin of plugins) {
+    if (seen.has(plugin.name)) {
+      throw new Error(`duplicate plugin name "${plugin.name}"`);
+    }
+    seen.add(plugin.name);
+  }
+}
+function createPluginHost(plugins) {
+  assertUniquePluginNames(plugins);
+  const validators = [];
+  const hooks = [];
+  const skills = [];
+  const repoSources = [];
+  const agentRoles = [];
+  const taskFieldExtensions = [];
+  const taskSources = [];
+  const cliCommands = [];
+  const capabilities = [];
+  const panels = [];
+  const blockerClassifiers = [];
+  const sessionExtensions = [];
+  const seedEntrypoints = [];
+  const stages = [];
+  const stageMutations = [];
+  const stageExecutors = {};
+  for (const plugin of plugins) {
+    const c = plugin.contributes;
+    if (!c)
+      continue;
+    const pluginName = plugin.name;
+    if (c.validators)
+      validators.push(...c.validators.map((item) => ({ item, pluginName })));
+    if (c.hooks)
+      hooks.push(...c.hooks.map((item) => ({ item, pluginName })));
+    if (c.skills)
+      skills.push(...c.skills.map((item) => ({ item, pluginName })));
+    if (c.repoSources)
+      repoSources.push(...c.repoSources.map((item) => ({ item, pluginName })));
+    if (c.agentRoles)
+      agentRoles.push(...c.agentRoles.map((item) => ({ item, pluginName })));
+    if (c.taskFieldSchemas)
+      taskFieldExtensions.push(...c.taskFieldSchemas.map((item) => ({ item, pluginName })));
+    if (c.taskSources)
+      taskSources.push(...c.taskSources.map((item) => ({ item, pluginName })));
+    if (c.cliCommands)
+      cliCommands.push(...c.cliCommands.map((item) => ({ item, pluginName })));
+    if (c.capabilities)
+      capabilities.push(...c.capabilities.map((item) => ({ item, pluginName })));
+    if (c.panels)
+      panels.push(...c.panels.map((item) => ({ item, pluginName })));
+    if (c.blockerClassifiers)
+      blockerClassifiers.push(...c.blockerClassifiers.map((item) => ({ item, pluginName })));
+    if (c.sessionExtensions)
+      sessionExtensions.push(...c.sessionExtensions.map((item) => ({ item, pluginName })));
+    if (c.seedEntrypoints)
+      seedEntrypoints.push(...c.seedEntrypoints.map((item) => ({ item, pluginName })));
+    if (c.stageMutations)
+      stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
+    if (c.stages) {
+      for (const stage of c.stages) {
+        stages.push({ item: stage, pluginName });
+        if (stage.run)
+          stageExecutors[stage.id] = stage.run;
+      }
+    }
+  }
+  const validatorMap = indexById(validators, "validator");
+  const hookMap = indexById(hooks, "hook");
+  const skillMap = indexById(skills, "skill");
+  const repoSourceMap = indexById(repoSources, "repoSource");
+  const agentRoleMap = indexById(agentRoles, "agentRole");
+  const taskFieldExtMap = indexById(taskFieldExtensions, "taskFieldExtension");
+  const taskSourceMap = indexById(taskSources, "taskSource");
+  const cliCommandMap = indexById(cliCommands, "cliCommand");
+  const capabilityMap = indexById(capabilities, "capability");
+  const panelMap = indexById(panels, "panel");
+  const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
+  indexById(sessionExtensions, "sessionExtension");
+  indexById(seedEntrypoints, "seedEntrypoint");
+  const taskSourceFactoryByKind = new Map;
+  const taskSourceKindRegistrant = new Map;
+  for (const { item, pluginName } of taskSources) {
+    if (taskSourceFactoryByKind.has(item.kind)) {
+      throw new Error(`duplicate task source kind "${item.kind}": registered by plugins "${taskSourceKindRegistrant.get(item.kind)}" and "${pluginName}"`);
+    }
+    taskSourceFactoryByKind.set(item.kind, item);
+    taskSourceKindRegistrant.set(item.kind, pluginName);
+  }
+  const seedEntrypointByBasename = new Map;
+  const seedEntrypointByWorkerArg = new Map;
+  let insidePtySeedEntrypoint;
+  const registerSeedEntrypointSelector = (map, selectorKind, selector, contribution) => {
+    const existing = map.get(selector);
+    if (existing) {
+      throw new Error(`duplicate seed entrypoint ${selectorKind} "${selector}": registered by entrypoint "${existing.item.id}" from plugin "${existing.pluginName}" and entrypoint "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    map.set(selector, contribution);
+  };
+  for (const contribution of seedEntrypoints) {
+    const entrypoint = contribution.item;
+    let selectorCount = 0;
+    if (entrypoint.basename) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByBasename, "basename", entrypoint.basename, contribution);
+    }
+    if (entrypoint.workerArg) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByWorkerArg, "workerArg", entrypoint.workerArg, contribution);
+    }
+    if (entrypoint.insidePty) {
+      selectorCount += 1;
+      if (insidePtySeedEntrypoint) {
+        throw new Error(`duplicate seed entrypoint inside-pty selector: registered by entrypoint "${insidePtySeedEntrypoint.item.id}" from plugin "${insidePtySeedEntrypoint.pluginName}" and entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}"`);
+      }
+      insidePtySeedEntrypoint = contribution;
+    }
+    if (selectorCount === 0) {
+      throw new Error(`seed entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}" must declare at least one selector (basename, workerArg, or insidePty)`);
+    }
+  }
+  const allValidators = validators.map((c) => c.item);
+  const allHooks = hooks.map((c) => c.item);
+  const allSkills = skills.map((c) => c.item);
+  const allRepoSources = repoSources.map((c) => c.item);
+  const allAgentRoles = agentRoles.map((c) => c.item);
+  const allTaskFieldExtensions = taskFieldExtensions.map((c) => c.item);
+  const allTaskSources = taskSources.map((c) => c.item);
+  const allCliCommands = cliCommands.map((c) => c.item);
+  const allStageMutations = stageMutations.map((c) => c.item);
+  const allStages = stages.map((c) => c.item);
+  const allCapabilities = capabilities.map((c) => c.item);
+  const allPanels = panels.map((c) => c.item);
+  const allBlockerClassifiers = blockerClassifiers.map((c) => c.item);
+  const allSessionExtensions = sessionExtensions.map((c) => c.item);
+  const allSeedEntrypoints = seedEntrypoints.map((c) => c.item);
+  const executableCliCommandByName = new Map;
+  const registerExecutableCliCommandSelector = (selector, contribution) => {
+    const existing = executableCliCommandByName.get(selector);
+    if (existing && existing.item.id !== contribution.item.id) {
+      throw new Error(`duplicate executable CLI selector "${selector}" registered by command "${existing.item.id}" from plugin "${existing.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    executableCliCommandByName.set(selector, contribution);
+  };
+  for (const contribution of cliCommands) {
+    const command = contribution.item;
+    const family = command.family ?? command.id;
+    registerExecutableCliCommandSelector(command.id, contribution);
+    registerExecutableCliCommandSelector(family, contribution);
+    for (const alias of command.aliases ?? []) {
+      registerExecutableCliCommandSelector(alias, contribution);
+    }
+  }
+  let defaultRootCliCommand;
+  for (const contribution of cliCommands) {
+    if (!contribution.item.rootDefault)
+      continue;
+    if (defaultRootCliCommand) {
+      throw new Error(`duplicate default root CLI command registered by command "${defaultRootCliCommand.item.id}" from plugin "${defaultRootCliCommand.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    defaultRootCliCommand = contribution;
+  }
+  return {
+    getValidator: (id) => validatorMap.get(id),
+    getHook: (id) => hookMap.get(id),
+    getSkill: (id) => skillMap.get(id),
+    getRepoSource: (id) => repoSourceMap.get(id),
+    getAgentRole: (id) => agentRoleMap.get(id),
+    getTaskFieldExtension: (id) => taskFieldExtMap.get(id),
+    getTaskSource: (id) => taskSourceMap.get(id),
+    getCliCommand: (id) => cliCommandMap.get(id),
+    getCapability: (id) => capabilityMap.get(id),
+    getPanel: (id) => panelMap.get(id),
+    getBlockerClassifier: (id) => blockerClassifierMap.get(id),
+    listValidators: () => allValidators,
+    listHooks: () => allHooks,
+    listSkills: () => allSkills,
+    listRepoSources: () => allRepoSources,
+    listAgentRoles: () => allAgentRoles,
+    listTaskFieldExtensions: () => allTaskFieldExtensions,
+    listTaskSources: () => allTaskSources,
+    listCliCommands: () => allCliCommands,
+    listCapabilities: () => allCapabilities,
+    listPanels: () => allPanels,
+    listBlockerClassifiers: () => allBlockerClassifiers,
+    listStages: () => allStages,
+    listStageMutations: () => allStageMutations,
+    listStageExecutors: () => stageExecutors,
+    listExecutableValidators: () => allValidators.filter((v) => typeof v.run === "function"),
+    listExecutableTaskSources: () => allTaskSources,
+    listExecutableCapabilities: () => allCapabilities.filter((c) => typeof c.run === "function"),
+    listExecutablePanels: () => allPanels.filter((p) => typeof p.produce === "function"),
+    listExecutableBlockerClassifiers: () => allBlockerClassifiers,
+    listExecutableCliCommands: () => allCliCommands,
+    listSessionExtensions: () => allSessionExtensions,
+    listSeedEntrypoints: () => allSeedEntrypoints,
+    resolveSeedEntrypointByBasename: (value) => seedEntrypointByBasename.get(value)?.item,
+    resolveSeedEntrypointByWorkerArg: (value) => seedEntrypointByWorkerArg.get(value)?.item,
+    resolveInsidePtySeedEntrypoint: () => insidePtySeedEntrypoint?.item,
+    resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
+    resolveDefaultRootCliCommand: () => defaultRootCliCommand?.item,
+    resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
+  };
+}
+// packages/core/src/capability.ts
+import { resolveCapability } from "@rig/kernel-seed";
+
+class CapabilityProviderMissingError extends Error {
+  capabilityId;
+  name = "CapabilityProviderMissingError";
+  constructor(capabilityId) {
+    super(`No provider resolved for capability "${capabilityId}"`);
+    this.capabilityId = capabilityId;
+  }
+}
+function isFactory(impl) {
+  return typeof impl === "function";
+}
+function defineCapability(id) {
+  const idString = String(id);
+  const tag = idString;
+  async function resolve(host) {
+    const providers = host.listExecutableCapabilities().filter((c) => c.id === idString && typeof c.run === "function").map((c) => ({
+      name: c.id,
+      provides: [c.id],
+      capabilityProviders: { [c.id]: c.run }
+    }));
+    const resolution = resolveCapability(providers, tag);
+    const run = resolution?.value;
+    if (!run)
+      return null;
+    return await run(undefined);
+  }
+  return {
+    id,
+    provide(impl, opts) {
+      return {
+        id: idString,
+        title: opts?.title ?? idString,
+        ...opts?.description !== undefined ? { description: opts.description } : {},
+        run: isFactory(impl) ? () => impl() : () => impl
+      };
+    },
+    resolve,
+    async require(host) {
+      const value = await resolve(host);
+      if (value === null)
+        throw new CapabilityProviderMissingError(idString);
+      return value;
+    }
+  };
+}
+function defineServiceCapability(id) {
+  const capability = defineCapability(id);
+  return {
+    ...capability,
+    provideService: capability.provide,
+    resolveService: capability.resolve,
+    requireService: capability.require
+  };
+}
+
+// packages/core/src/index.ts
+var RIG_CORE_PACKAGE = "@rig/core";
+export {
+  defineServiceCapability,
+  definePlugin,
+  defineConfig,
+  defineCapability,
+  createPluginHost,
+  RIG_CORE_PACKAGE,
+  CapabilityProviderMissingError
+};

package/dist/src/json-files.d.ts

@@ -0,0 +1,9 @@
+export declare function appendJsonlRecord(path: string, value: unknown): void;
+export declare function writeJsonFile(path: string, value: unknown): void;
+export declare function readJsonFile<T>(path: string, fallback: T): T;
+export declare function readAuthorityStateJson<T>(projectRoot: string, relativePath: string, fallback: T): T;
+export declare function writeAuthorityStateJson(projectRoot: string, relativePath: string, value: unknown): string;
+export declare function readAuthorityProjectStateJson<T>(projectRoot: string, relativePath: string, fallback: T): T;
+export declare function writeAuthorityProjectStateJson(projectRoot: string, relativePath: string, value: unknown): string;
+export declare function readJsonlFile(path: string): unknown[];
+export declare function stripAuthorityRunLiveCollabFields<T extends Record<string, unknown>>(record: T): T;

package/dist/src/json-files.js

@@ -0,0 +1,124 @@
+// @bun
+// packages/core/src/json-files.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+
+// packages/core/src/layout.ts
+import {
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// packages/core/src/authority-paths.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveAuthorityStateRoot(projectRoot) {
+  const normalizedRoot = resolve(projectRoot);
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  if (taskWorkspace) {
+    return resolve(taskWorkspace, ".rig");
+  }
+  const stateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (stateDir) {
+    return dirname(resolve(stateDir));
+  }
+  const logsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  if (logsDir) {
+    return dirname(resolve(logsDir));
+  }
+  const sessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  if (sessionFile) {
+    return dirname(dirname(resolve(sessionFile)));
+  }
+  const projectStateRoot = resolve(normalizedRoot, ".rig");
+  if (existsSync(projectStateRoot)) {
+    return projectStateRoot;
+  }
+  return resolve(normalizedRoot, ".rig");
+}
+function resolveAuthorityStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve(explicit);
+  }
+  return resolve(resolveAuthorityStateRoot(projectRoot), "state");
+}
+function resolveAuthorityProjectStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve(explicit);
+  }
+  return resolve(resolve(projectRoot), ".rig", "state");
+}
+// packages/core/src/json-files.ts
+function appendJsonlRecord(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(value)}
+`, "utf8");
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync2(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function readAuthorityStateJson(projectRoot, relativePath, fallback) {
+  return readJsonFile(resolve2(resolveAuthorityStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityStateJson(projectRoot, relativePath, value) {
+  const path = resolve2(resolveAuthorityStateDir(projectRoot), relativePath);
+  writeJsonFile(path, value);
+  return path;
+}
+function readAuthorityProjectStateJson(projectRoot, relativePath, fallback) {
+  return readJsonFile(resolve2(resolveAuthorityProjectStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityProjectStateJson(projectRoot, relativePath, value) {
+  const path = resolve2(resolveAuthorityProjectStateDir(projectRoot), relativePath);
+  writeJsonFile(path, value);
+  return path;
+}
+function readJsonlFile(path) {
+  if (!existsSync2(path))
+    return [];
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function stripAuthorityRunLiveCollabFields(record) {
+  const {
+    collabLink: _collabLink,
+    collabWebLink: _collabWebLink,
+    collabRoomId: _collabRoomId,
+    collabRelayUrl: _collabRelayUrl,
+    collabToken: _collabToken,
+    ...rest
+  } = record;
+  return rest;
+}
+export {
+  writeJsonFile,
+  writeAuthorityStateJson,
+  writeAuthorityProjectStateJson,
+  stripAuthorityRunLiveCollabFields,
+  readJsonlFile,
+  readJsonFile,
+  readAuthorityStateJson,
+  readAuthorityProjectStateJson,
+  appendJsonlRecord
+};

package/dist/src/kernel-boot.d.ts

@@ -0,0 +1,2 @@
+export { bootDefaultKernelIntoProcess, getProcessKernel, } from "@rig/kernel-seed/boot-default";
+export type { DefaultKernelBootRecord } from "@rig/kernel-seed/boot-default";

package/dist/src/kernel-boot.js

@@ -0,0 +1,10 @@
+// @bun
+// packages/core/src/kernel-boot.ts
+import {
+  bootDefaultKernelIntoProcess,
+  getProcessKernel
+} from "@rig/kernel-seed/boot-default";
+export {
+  getProcessKernel,
+  bootDefaultKernelIntoProcess
+};

package/dist/src/kernel-entrypoint.d.ts

@@ -0,0 +1,22 @@
+import type { JournalCapability, TransportCapability } from "@rig/contracts";
+import { type DefaultKernelBootRecord } from "./kernel-boot";
+import type { CapabilityProviderPlugin } from "./kernel-plugin-abi";
+export type HydrationResult = {
+    readonly projectRoot: string;
+    readonly dotenvLoaded: boolean;
+    readonly configLoaded: boolean;
+    readonly errors: readonly string[];
+};
+export type HydrateProjectProcessEnvOptions = {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly dotenvPath?: string;
+};
+export type AdoptKernelOptions = HydrateProjectProcessEnvOptions & {
+    readonly entrypoint?: string;
+    readonly journal?: JournalCapability;
+    readonly transport?: TransportCapability;
+    readonly hydrateEnv?: boolean;
+};
+export declare function createPlacementKernelTransportPlugin(transport: TransportCapability): CapabilityProviderPlugin;
+export declare function hydrateProjectProcessEnv(projectRoot: string, options?: HydrateProjectProcessEnvOptions): Promise<HydrationResult>;
+export declare function adopt(root?: string, options?: AdoptKernelOptions): Promise<DefaultKernelBootRecord>;