@h-rig/task-sources-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/control-plane/task-fields.d.ts

@@ -0,0 +1 @@
+export { createTaskFieldRegistry, type TaskFieldRegistry } from "@rig/core/plugin-host-registries";

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

@@ -0,0 +1,6 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/task-fields.ts
+import { createTaskFieldRegistry } from "@rig/core/plugin-host-registries";
+export {
+  createTaskFieldRegistry
+};

package/dist/src/control-plane/task-io-service.d.ts

@@ -0,0 +1,6 @@
+import type { RegisteredTaskSource, TaskIoService } from "@rig/contracts";
+export type TaskSourceHandle = {
+    readonly kind: string;
+    readonly source: RegisteredTaskSource;
+};
+export declare function createTaskIoService(): TaskIoService;

package/dist/src/control-plane/task-io-service.js

@@ -0,0 +1,108 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/task-io-service.ts
+import { resolvePluginHost } from "@rig/core/project-plugins";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function taskText(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function taskUrl(record) {
+  const metadata = record;
+  return taskText(metadata.url) ?? taskText(metadata.html_url) ?? taskText(metadata.webUrl);
+}
+function taskBody(record) {
+  const metadata = record;
+  return taskText(metadata.body) ?? taskText(metadata.description);
+}
+function taskTitle(record) {
+  const metadata = record;
+  return taskText(metadata.title) ?? taskText(metadata.name) ?? record.id;
+}
+function taskStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function taskDependencies(record) {
+  const raw = record;
+  const dependencies = taskStringList(raw.dependencies);
+  if (dependencies.length > 0)
+    return dependencies;
+  const deps = taskStringList(raw.deps);
+  return deps.length > 0 ? deps : null;
+}
+function taskParentChildDeps(record) {
+  const raw = record;
+  const parentChildDeps = taskStringList(raw.parentChildDeps);
+  if (parentChildDeps.length > 0)
+    return parentChildDeps;
+  const parents = taskStringList(raw.parents);
+  return parents.length > 0 ? parents : null;
+}
+function taskCreateInput(task) {
+  const deps = Array.isArray(task.dependencies) ? task.dependencies.filter((entry) => typeof entry === "string") : Array.isArray(task.deps) ? task.deps.filter((entry) => typeof entry === "string") : [];
+  const parents = Array.isArray(task.parents) ? task.parents.filter((entry) => typeof entry === "string") : [];
+  return {
+    title: taskText(task.title) ?? taskText(task.name) ?? "Untitled task",
+    body: taskText(task.body) ?? taskText(task.description) ?? "",
+    ...deps.length > 0 ? { deps } : {},
+    ...parents.length > 0 ? { parents } : {},
+    metadata: { ...task }
+  };
+}
+function toRigTask(record, sourceKind) {
+  const dependencies = taskDependencies(record);
+  const parentChildDeps = taskParentChildDeps(record);
+  return {
+    ...record,
+    id: record.id,
+    title: taskTitle(record),
+    status: typeof record.status === "string" ? record.status : null,
+    source: sourceKind,
+    url: taskUrl(record),
+    body: taskBody(record),
+    ...dependencies ? { dependencies } : {},
+    ...parentChildDeps ? { parentChildDeps } : {}
+  };
+}
+async function loadTaskSource(projectRoot) {
+  const { config, host: pluginHost } = await resolvePluginHost(projectRoot);
+  const factory = pluginHost.resolveTaskSourceFactoryByKind(config.taskSource.kind);
+  if (!factory) {
+    const kinds = pluginHost.listExecutableTaskSources().map((entry) => entry.kind).join(", ") || "none";
+    throw new Error(`No task source factory registered for kind ${config.taskSource.kind}. Registered task sources: ${kinds}.`);
+  }
+  return { kind: config.taskSource.kind, source: factory.factory(config.taskSource, { projectRoot }) };
+}
+function getTaskCreator(source) {
+  const record = source;
+  if (typeof record.createTask === "function")
+    return record.createTask.bind(source);
+  if (typeof record.create === "function")
+    return (task) => record.create?.(taskCreateInput(task));
+  return null;
+}
+function createTaskIoService() {
+  return {
+    async listTasks(projectRoot) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      return (await source.list()).map((task) => toRigTask(task, kind));
+    },
+    async getTask(projectRoot, taskId) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      const task = source.get ? await source.get(taskId) ?? null : (await source.list()).find((entry) => entry.id === taskId) ?? null;
+      return task ? toRigTask(task, kind) : null;
+    },
+    async createTask(projectRoot, task) {
+      const { kind, source } = await loadTaskSource(projectRoot);
+      const creator = getTaskCreator(source);
+      if (!creator)
+        throw new Error(`The configured ${kind} task source does not expose a task creation API.`);
+      const result = await creator(task);
+      const taskId = typeof result === "string" ? result : isRecord(result) && typeof result.id === "string" ? result.id : null;
+      return { taskId, source: kind, result };
+    }
+  };
+}
+export {
+  createTaskIoService
+};

package/dist/src/control-plane/task-source-bootstrap.d.ts

@@ -0,0 +1 @@
+export { buildTaskSourceRegistry } from "@rig/core/plugin-host-registries";

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

@@ -0,0 +1,6 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/task-source-bootstrap.ts
+import { buildTaskSourceRegistry } from "@rig/core/plugin-host-registries";
+export {
+  buildTaskSourceRegistry
+};

package/dist/src/control-plane/task-source.d.ts

@@ -0,0 +1,2 @@
+export type { TaskRecord, RegisteredTaskSource } from "@rig/contracts";
+export { createTaskSourceRegistry, type TaskSourceRegistry } from "@rig/core/plugin-host-registries";

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

@@ -0,0 +1,6 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/task-source.ts
+import { createTaskSourceRegistry } from "@rig/core/plugin-host-registries";
+export {
+  createTaskSourceRegistry
+};

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

@@ -0,0 +1,19 @@
+import type { TaskRecord } from "@rig/contracts";
+import { type TaskRecordReader } from "@rig/core/task-record-reader";
+export type LegacyTaskConfigReaderOptions = {
+    configPath?: string;
+};
+export declare class LegacyTaskConfigReadError extends Error {
+    readonly code = "LEGACY_TASK_CONFIG_READ_FAILED";
+    readonly projectRoot: string;
+    readonly configPath: string;
+    readonly cause: unknown;
+    constructor(input: {
+        projectRoot: string;
+        configPath: string;
+        message: string;
+        cause?: unknown;
+    });
+}
+export declare function createLegacyTaskConfigRecordReader(projectRoot: string, options?: LegacyTaskConfigReaderOptions): TaskRecordReader;
+export declare function readLegacyTaskRecords(projectRoot: string, configPath?: string): readonly TaskRecord[];

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

@@ -0,0 +1,124 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/tasks/legacy-task-config-source.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { findTaskById } from "@rig/core/task-record-reader";
+
+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.d.ts

@@ -0,0 +1,30 @@
+import type { TaskSourceRegistry } from "../task-source";
+import { type TaskRecordReader } from "@rig/core/task-record-reader";
+export type PluginTaskRecordReaderContext = {
+    taskSourceRegistry: Pick<TaskSourceRegistry, "list" | "resolveById" | "resolveByKind">;
+};
+export type PluginTaskRecordReaderOptions = {
+    projectRoot: string;
+    sourceId?: string;
+    sourceKind?: string;
+};
+export type TaskRecordSourceErrorCode = "TASK_SOURCE_NOT_CONFIGURED" | "TASK_SOURCE_READ_FAILED";
+export type TaskRecordSourceOperation = "select" | "list" | "get";
+export declare class TaskRecordSourceError extends Error {
+    readonly code: TaskRecordSourceErrorCode;
+    readonly projectRoot: string;
+    readonly sourceId: string | null;
+    readonly sourceKind: string | null;
+    readonly operation: TaskRecordSourceOperation;
+    readonly cause: unknown;
+    constructor(input: {
+        code: TaskRecordSourceErrorCode;
+        message: string;
+        projectRoot: string;
+        operation: TaskRecordSourceOperation;
+        sourceId?: string | null;
+        sourceKind?: string | null;
+        cause?: unknown;
+    });
+}
+export declare function createPluginTaskRecordReader(context: PluginTaskRecordReaderContext, options: PluginTaskRecordReaderOptions): TaskRecordReader;

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

@@ -0,0 +1,99 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/tasks/plugin-task-source.ts
+import { findTaskById } from "@rig/core/task-record-reader";
+
+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
+};

package/dist/src/control-plane/tasks/source-aware-task-config-source.d.ts

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process";
+import type { TaskSourceUpdate } from "@rig/contracts";
+import type { TaskRecordReader } from "@rig/core/task-record-reader";
+export type MaterializedTaskSourceMetadata = {
+    kind: string;
+    path?: string;
+    owner?: string;
+    repo?: string;
+    labels?: readonly string[];
+    state?: "open" | "closed" | "all";
+};
+export type MaterializedTaskMetadata = {
+    taskSource?: MaterializedTaskSourceMetadata;
+    sourceIssueId?: string;
+};
+export type SourceAwareTaskConfigOptions = {
+    configPath?: string;
+    ghBinary?: string;
+    spawn?: typeof spawnSync;
+    allowLocalTaskConfigStatusFallback?: boolean;
+};
+type RawTaskEntry = Record<string, unknown>;
+export declare function createSourceAwareTaskConfigRecordReader(projectRoot: string, options?: SourceAwareTaskConfigOptions): TaskRecordReader;
+export declare function readSourceAwareTaskStatus(projectRoot: string, taskId: string, options?: SourceAwareTaskConfigOptions): Promise<unknown>;
+export declare function updateGithubIssueTaskBySourceIssueId(sourceIssueId: string | null | undefined, taskId: string, update: TaskSourceUpdate, options?: SourceAwareTaskConfigOptions): boolean;
+export declare function updateSourceAwareTaskConfigTask(projectRoot: string, taskId: string, update: TaskSourceUpdate, options?: SourceAwareTaskConfigOptions): boolean;
+export declare function readMaterializedTaskMetadata(entry: RawTaskEntry): MaterializedTaskMetadata;
+export {};