@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/task-fields.js

@@ -0,0 +1,38 @@
+// @bun
+// 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 };
+    }
+  };
+}
+export {
+  createTaskFieldRegistry
+};

package/dist/src/control-plane/task-source-bootstrap.js

@@ -0,0 +1,46 @@
+// @bun
+// 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;
+}
+export {
+  buildTaskSourceRegistry
+};

package/dist/src/control-plane/task-source.js

@@ -0,0 +1,30 @@
+// @bun
+// 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
+  };
+}
+export {
+  createTaskSourceRegistry
+};

package/dist/src/control-plane/tasks/legacy-task-config-source.js

@@ -0,0 +1,130 @@
+// @bun
+// packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+// packages/runtime/src/control-plane/tasks/task-record-reader.ts
+async function findTaskById(reader, id) {
+  const tasks = await reader.listTasks();
+  return tasks.find((task) => task.id === id) ?? null;
+}
+
+// packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
+class LegacyTaskConfigReadError extends Error {
+  code = "LEGACY_TASK_CONFIG_READ_FAILED";
+  projectRoot;
+  configPath;
+  cause;
+  constructor(input) {
+    super(input.message, { cause: input.cause });
+    this.name = "LegacyTaskConfigReadError";
+    this.projectRoot = input.projectRoot;
+    this.configPath = input.configPath;
+    this.cause = input.cause;
+  }
+}
+function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
+  const configPath = options.configPath ?? resolve(projectRoot, ".rig", "task-config.json");
+  const reader = {
+    async listTasks() {
+      return readLegacyTaskRecords(projectRoot, configPath);
+    },
+    async getTask(id) {
+      return findTaskById(reader, id);
+    }
+  };
+  return reader;
+}
+function readLegacyTaskRecords(projectRoot, configPath = resolve(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync(configPath)) {
+    return [];
+  }
+  const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
+  return Object.entries(stripLegacyTaskConfigMetadata(rawConfig)).map(([id, entry]) => legacyTaskConfigEntryToRecord(id, entry)).filter((record) => record !== null);
+}
+function readLegacyTaskConfigJson(projectRoot, configPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    if (isPlainRecord(parsed)) {
+      return parsed;
+    }
+    throw new Error("task config root must be a JSON object");
+  } catch (cause) {
+    throw new LegacyTaskConfigReadError({
+      projectRoot,
+      configPath,
+      message: `Could not read legacy task config at ${configPath} for project ${projectRoot}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      cause
+    });
+  }
+}
+function stripLegacyTaskConfigMetadata(raw) {
+  const { validation_descriptions: _legacyDescriptions, _meta, ...tasks } = raw;
+  return tasks;
+}
+function legacyTaskConfigEntryToRecord(id, entry) {
+  if (!isPlainRecord(entry)) {
+    return null;
+  }
+  const deps = firstStringList(entry.deps, entry.dependencies, entry.validation_deps, entry.validationDeps);
+  const validation = readStringList(entry.validation);
+  const validators = readStringList(entry.validators);
+  const scope = readStringList(entry.scope);
+  const status = typeof entry.status === "string" ? entry.status : "open";
+  const title = typeof entry.title === "string" ? entry.title : undefined;
+  const description = typeof entry.description === "string" ? entry.description : undefined;
+  const acceptanceCriteria = typeof entry.acceptance_criteria === "string" ? entry.acceptance_criteria : typeof entry.acceptanceCriteria === "string" ? entry.acceptanceCriteria : undefined;
+  return {
+    id,
+    deps,
+    status,
+    source: "legacy-task-config",
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ...acceptanceCriteria ? { acceptanceCriteria } : {},
+    ...scope.length > 0 ? { scope } : {},
+    ...validation.length > 0 ? { validation } : {},
+    ...validators.length > 0 ? { validators } : {},
+    ...preservedLegacyFields(entry)
+  };
+}
+function preservedLegacyFields(entry) {
+  const preserved = {};
+  for (const key of [
+    "role",
+    "browser",
+    "repo_pins",
+    "criticality",
+    "queue_weight",
+    "creates_repo",
+    "auto_synced"
+  ]) {
+    if (entry[key] !== undefined) {
+      preserved[key] = entry[key];
+    }
+  }
+  return preserved;
+}
+function firstStringList(...candidates) {
+  for (const candidate of candidates) {
+    const list = readStringList(candidate);
+    if (list.length > 0) {
+      return list;
+    }
+  }
+  return [];
+}
+function readStringList(candidate) {
+  if (!Array.isArray(candidate)) {
+    return [];
+  }
+  return candidate.filter((value) => typeof value === "string");
+}
+function isPlainRecord(candidate) {
+  return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+}
+export {
+  readLegacyTaskRecords,
+  createLegacyTaskConfigRecordReader,
+  LegacyTaskConfigReadError
+};

package/dist/src/control-plane/tasks/plugin-task-source.js

@@ -0,0 +1,103 @@
+// @bun
+// packages/runtime/src/control-plane/tasks/task-record-reader.ts
+async function findTaskById(reader, id) {
+  const tasks = await reader.listTasks();
+  return tasks.find((task) => task.id === id) ?? null;
+}
+
+// packages/runtime/src/control-plane/tasks/plugin-task-source.ts
+class TaskRecordSourceError extends Error {
+  code;
+  projectRoot;
+  sourceId;
+  sourceKind;
+  operation;
+  cause;
+  constructor(input) {
+    super(input.message, { cause: input.cause });
+    this.name = "TaskRecordSourceError";
+    this.code = input.code;
+    this.projectRoot = input.projectRoot;
+    this.operation = input.operation;
+    this.sourceId = input.sourceId ?? null;
+    this.sourceKind = input.sourceKind ?? null;
+    this.cause = input.cause;
+  }
+}
+function createPluginTaskRecordReader(context, options) {
+  const source = selectTaskSource(context.taskSourceRegistry, options);
+  return {
+    async listTasks() {
+      try {
+        return await source.list();
+      } catch (cause) {
+        throw readFailedError(source, options, "list", cause);
+      }
+    },
+    async getTask(id) {
+      try {
+        if (source.get) {
+          return await source.get(id) ?? null;
+        }
+        return findTaskById({
+          listTasks: () => source.list(),
+          getTask: async () => null
+        }, id);
+      } catch (cause) {
+        throw readFailedError(source, options, "get", cause);
+      }
+    }
+  };
+}
+function selectTaskSource(registry, options) {
+  try {
+    if (options.sourceId) {
+      return registry.resolveById(options.sourceId);
+    }
+    if (options.sourceKind) {
+      return registry.resolveByKind(options.sourceKind);
+    }
+    const [source] = registry.list();
+    if (source) {
+      return source;
+    }
+  } catch (cause) {
+    throw new TaskRecordSourceError({
+      code: "TASK_SOURCE_NOT_CONFIGURED",
+      message: taskSourceSelectionMessage(options),
+      projectRoot: options.projectRoot,
+      operation: "select",
+      sourceId: options.sourceId ?? null,
+      sourceKind: options.sourceKind ?? null,
+      cause
+    });
+  }
+  throw new TaskRecordSourceError({
+    code: "TASK_SOURCE_NOT_CONFIGURED",
+    message: taskSourceSelectionMessage(options),
+    projectRoot: options.projectRoot,
+    operation: "select",
+    sourceId: options.sourceId ?? null,
+    sourceKind: options.sourceKind ?? null
+  });
+}
+function taskSourceSelectionMessage(options) {
+  const selector = options.sourceId ? `id "${options.sourceId}"` : options.sourceKind ? `kind "${options.sourceKind}"` : "the configured plugin task source";
+  return `No task source registered for ${selector} in project ${options.projectRoot}. Check rig.config.ts taskSource and loaded plugins.`;
+}
+function readFailedError(source, options, operation, cause) {
+  const causeMessage = cause instanceof Error ? cause.message : String(cause);
+  return new TaskRecordSourceError({
+    code: "TASK_SOURCE_READ_FAILED",
+    message: `Task source ${source.kind} (${source.id}) failed to ${operation} tasks for project ${options.projectRoot}: ${causeMessage}`,
+    projectRoot: options.projectRoot,
+    operation,
+    sourceId: source.id,
+    sourceKind: source.kind,
+    cause
+  });
+}
+export {
+  createPluginTaskRecordReader,
+  TaskRecordSourceError
+};