@h-rig/core 0.0.6-alpha.0

package/dist/src/load-config.js

@@ -0,0 +1,49 @@
+// @bun
+// packages/core/src/load-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { pathToFileURL } from "url";
+import { Schema } from "effect";
+import { RigConfig } from "@rig/contracts";
+var TS_NAMES = ["rig.config.ts", "rig.config.mts"];
+var JSON_NAMES = ["rig.config.json"];
+async function loadConfig(cwd) {
+  for (const name of TS_NAMES) {
+    const p = join(cwd, name);
+    if (existsSync(p)) {
+      const mod = await import(pathToFileURL(p).href);
+      const raw = mod.default ?? mod.config;
+      return decodePreservingRuntime(raw);
+    }
+  }
+  for (const name of JSON_NAMES) {
+    const p = join(cwd, name);
+    if (existsSync(p)) {
+      const raw = JSON.parse(readFileSync(p, "utf-8"));
+      return decodePreservingRuntime(raw);
+    }
+  }
+  throw new Error(`no rig.config.{ts,mts,json} found in ${cwd}`);
+}
+function decodePreservingRuntime(raw) {
+  const runtimeByName = new Map;
+  const cfgIn = raw;
+  if (Array.isArray(cfgIn?.plugins)) {
+    for (const plugin of cfgIn.plugins) {
+      if (plugin?.__runtime) {
+        runtimeByName.set(plugin.name, plugin.__runtime);
+      }
+    }
+  }
+  const decoded = Schema.decodeUnknownSync(RigConfig)(raw);
+  const plugins = decoded.plugins.map((p) => {
+    const runtime = runtimeByName.get(p.name);
+    if (!runtime)
+      return p;
+    return { ...p, __runtime: runtime };
+  });
+  return { ...decoded, plugins };
+}
+export {
+  loadConfig
+};

package/dist/src/plugin-host.js

@@ -0,0 +1,158 @@
+// @bun
+// 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 assertRuntimeMatchesMetadata(plugin) {
+  const declaredValidators = new Map((plugin.contributes?.validators ?? []).map((validator) => [validator.id, validator]));
+  const runtimeValidators = new Map((plugin.__runtime?.validators ?? []).map((validator) => [validator.id, validator]));
+  for (const validator of runtimeValidators.values()) {
+    const metadata = declaredValidators.get(validator.id);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" executable validator "${validator.id}" has no matching metadata entry in contributes.validators`);
+    }
+    if (metadata.category !== validator.category) {
+      throw new Error(`plugin "${plugin.name}" executable validator "${validator.id}" category "${validator.category}" does not match metadata category "${metadata.category}"`);
+    }
+  }
+  if (plugin.__runtime?.validators) {
+    for (const validator of declaredValidators.values()) {
+      if (!runtimeValidators.has(validator.id)) {
+        throw new Error(`plugin "${plugin.name}" validator metadata "${validator.id}" has no runtime implementation`);
+      }
+    }
+  }
+  const declaredTaskSources = new Map((plugin.contributes?.taskSources ?? []).map((source) => [source.id, source]));
+  const runtimeTaskSources = new Map((plugin.__runtime?.taskSources ?? []).map((source) => [source.id, source]));
+  for (const source of runtimeTaskSources.values()) {
+    const metadata = declaredTaskSources.get(source.id);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" executable task source "${source.id}" has no matching metadata entry in contributes.taskSources`);
+    }
+    if (metadata.kind !== source.kind) {
+      throw new Error(`plugin "${plugin.name}" executable task source "${source.id}" kind "${source.kind}" does not match metadata kind "${metadata.kind}"`);
+    }
+  }
+  if (plugin.__runtime?.taskSources) {
+    for (const source of declaredTaskSources.values()) {
+      if (!runtimeTaskSources.has(source.id)) {
+        throw new Error(`plugin "${plugin.name}" task source metadata "${source.id}" has no runtime implementation`);
+      }
+    }
+  }
+}
+function createPluginHost(plugins) {
+  assertUniquePluginNames(plugins);
+  for (const plugin of plugins) {
+    assertRuntimeMatchesMetadata(plugin);
+  }
+  const validators = [];
+  const hooks = [];
+  const skills = [];
+  const repoSources = [];
+  const agentRoles = [];
+  const taskFieldExtensions = [];
+  const taskSources = [];
+  const cliCommands = [];
+  const executableValidators = [];
+  const executableTaskSources = [];
+  for (const plugin of plugins) {
+    const c = plugin.contributes;
+    if (!c)
+      continue;
+    const pluginName = plugin.name;
+    if (plugin.__runtime?.validators) {
+      executableValidators.push(...plugin.__runtime.validators.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.taskSources) {
+      executableTaskSources.push(...plugin.__runtime.taskSources.map((item) => ({ item, pluginName })));
+    }
+    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 })));
+  }
+  indexById(executableValidators, "executableValidator");
+  indexById(executableTaskSources, "executableTaskSource");
+  const taskSourceFactoryByKind = new Map;
+  const taskSourceKindRegistrant = new Map;
+  for (const { item, pluginName } of executableTaskSources) {
+    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 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 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 allExecutableValidators = executableValidators.map((c) => c.item);
+  const allExecutableTaskSources = executableTaskSources.map((c) => c.item);
+  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),
+    listValidators: () => allValidators,
+    listHooks: () => allHooks,
+    listSkills: () => allSkills,
+    listRepoSources: () => allRepoSources,
+    listAgentRoles: () => allAgentRoles,
+    listTaskFieldExtensions: () => allTaskFieldExtensions,
+    listTaskSources: () => allTaskSources,
+    listCliCommands: () => allCliCommands,
+    listExecutableValidators: () => allExecutableValidators,
+    listExecutableTaskSources: () => allExecutableTaskSources,
+    resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
+  };
+}
+export {
+  createPluginHost
+};

package/dist/src/plugin-runtime.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/rig-init-builder.js

@@ -0,0 +1,57 @@
+// @bun
+// packages/core/src/rig-init-builder.ts
+function buildRigInitConfigSource(input) {
+  const lines = [`import { defineConfig } from "@rig/core";`];
+  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
+    lines.push(`import standard, { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
+  } else if (input.useStandardPlugin) {
+    lines.push(`import standard from "@rig/standard-plugin";`);
+  }
+  lines.push(``, `export default defineConfig({`);
+  const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
+  lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
+  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
+    lines.push(`  plugins: [standard({`);
+    lines.push(`    githubCredentialProvider: createStateGitHubCredentialProvider(),`);
+    lines.push(`    githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
+    lines.push(`    githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
+    lines.push(`  })],`);
+  } else {
+    lines.push(`  plugins: [${input.useStandardPlugin ? "standard()" : ""}],`);
+  }
+  if (input.taskSource.kind === "github-issues") {
+    lines.push(`  taskSource: {`);
+    lines.push(`    kind: "github-issues",`);
+    lines.push(`    owner: ${JSON.stringify(input.taskSource.owner)},`);
+    lines.push(`    repo: ${JSON.stringify(input.taskSource.repo)},`);
+    lines.push(`    // labels: ["task"],  // uncomment to filter by labels`);
+    lines.push(`    state: "open",`);
+    if (input.taskSource.assignee?.trim()) {
+      lines.push(`    options: { assignee: ${JSON.stringify(input.taskSource.assignee.trim())} },`);
+    }
+    lines.push(`  },`);
+  } else {
+    lines.push(`  taskSource: {`);
+    lines.push(`    kind: "files",`);
+    lines.push(`    path: ${JSON.stringify(input.taskSource.path)},`);
+    lines.push(`  },`);
+  }
+  lines.push(`  workspace: { mainRepo: ".", isolation: "worktree" },`);
+  lines.push(`  runtime: { harness: "pi", mode: "yolo" },`);
+  lines.push(`  planning: { mode: "auto" },`);
+  lines.push(`  github: {`);
+  lines.push(`    issueUpdates: "lifecycle",`);
+  lines.push(`    projects: { enabled: false },`);
+  lines.push(`  },`);
+  lines.push(`  automation: { maxValidationAttempts: 30, maxPrFixIterations: 30 },`);
+  lines.push(`  pr: { mode: "auto", watchChecks: true, autoFixChecks: true, autoFixReview: true },`);
+  lines.push(`  merge: { mode: "auto", method: "repo-default", deleteBranch: "repo-default", bypass: false },`);
+  lines.push(`  issueAnalysis: { enabled: true, harness: "pi", mode: "continuous" },`);
+  lines.push(`});`);
+  lines.push(``);
+  return lines.join(`
+`);
+}
+export {
+  buildRigInitConfigSource
+};

package/dist/src/rigSelectors.js

@@ -0,0 +1,293 @@
+// @bun
+// packages/core/src/rigSelectors.ts
+function selectWorkspaces(snapshot) {
+  return snapshot?.workspaces ?? [];
+}
+function selectPrimaryWorkspace(snapshot) {
+  const workspaces = selectWorkspaces(snapshot);
+  return workspaces.find((workspace) => workspace.sourceKind === "rig-import") ?? workspaces[0] ?? null;
+}
+function pickDefaultWorkspaceId(snapshot) {
+  return selectPrimaryWorkspace(snapshot)?.id ?? null;
+}
+function selectWorkspace(snapshot, workspaceId) {
+  if (!workspaceId)
+    return null;
+  return snapshot?.workspaces.find((workspace) => workspace.id === workspaceId) ?? null;
+}
+function selectTask(snapshot, taskId) {
+  if (!taskId)
+    return null;
+  return snapshot?.tasks.find((task) => task.id === taskId) ?? null;
+}
+function selectTasksByWorkspace(snapshot, workspaceId) {
+  if (!workspaceId)
+    return [];
+  return snapshot?.tasks.filter((task) => task.workspaceId === workspaceId) ?? [];
+}
+var selectTasksForWorkspace = selectTasksByWorkspace;
+function selectTasksByStatus(snapshot, status) {
+  return snapshot?.tasks.filter((task) => task.status === status) ?? [];
+}
+function projectTaskStatusForGrouping(status) {
+  switch (status) {
+    case "failed":
+      return "ready";
+    case "closed":
+      return "completed";
+    case "running":
+    case "in_progress":
+    case "under_review":
+      return "running";
+    default:
+      return status;
+  }
+}
+var STATUS_PRIORITY = [
+  "running",
+  "blocked",
+  "queued",
+  "ready",
+  "open",
+  "draft",
+  "unknown",
+  "cancelled",
+  "completed"
+];
+function selectTasksGroupedByStatus(snapshot, workspaceId) {
+  const tasks = selectTasksByWorkspace(snapshot, workspaceId);
+  const byStatus = new Map;
+  for (const task of tasks) {
+    const projectedStatus = projectTaskStatusForGrouping(task.status);
+    const group = byStatus.get(projectedStatus);
+    if (group) {
+      group.push(task);
+    } else {
+      byStatus.set(projectedStatus, [task]);
+    }
+  }
+  const result = [];
+  for (const status of STATUS_PRIORITY) {
+    const group = byStatus.get(status);
+    if (group && group.length > 0) {
+      result.push({ status, tasks: group });
+    }
+  }
+  const overflowStatuses = Array.from(byStatus.keys()).filter((status) => !STATUS_PRIORITY.includes(status)).sort();
+  for (const status of overflowStatuses) {
+    const group = byStatus.get(status);
+    if (group && group.length > 0) {
+      result.push({ status, tasks: group });
+    }
+  }
+  return result;
+}
+function selectRun(snapshot, runId) {
+  if (!runId)
+    return null;
+  return snapshot?.runs.find((run) => run.id === runId) ?? null;
+}
+function selectRunsByTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  return snapshot?.runs.filter((run) => run.taskId === taskId) ?? [];
+}
+var selectRunsForTask = selectRunsByTask;
+function selectRunsForWorkspace(snapshot, workspaceId) {
+  if (!workspaceId)
+    return [];
+  return snapshot?.runs.filter((run) => run.workspaceId === workspaceId) ?? [];
+}
+function selectAdhocRuns(snapshot) {
+  return snapshot?.runs.filter((run) => run.taskId === null) ?? [];
+}
+function selectAdhocRunsForWorkspace(snapshot, workspaceId) {
+  if (!workspaceId)
+    return [];
+  return snapshot?.runs.filter((run) => run.taskId === null && run.workspaceId === workspaceId) ?? [];
+}
+function selectGraphsForWorkspace(snapshot, workspaceId) {
+  if (!workspaceId)
+    return [];
+  return snapshot?.graphs.filter((graph) => graph.workspaceId === workspaceId) ?? [];
+}
+function selectQueueForWorkspace(snapshot, workspaceId) {
+  if (!snapshot || !workspaceId)
+    return [];
+  const taskIds = new Set(selectTasksByWorkspace(snapshot, workspaceId).map((task) => task.id));
+  return snapshot.queue.filter((entry) => taskIds.has(entry.taskId));
+}
+function selectPendingApprovals(snapshot) {
+  return snapshot?.approvals.filter((approval) => approval.status === "pending") ?? [];
+}
+function selectApprovalsForRun(snapshot, runId) {
+  if (!runId)
+    return [];
+  return snapshot?.approvals.filter((approval) => approval.runId === runId) ?? [];
+}
+function selectPendingApprovalsForRun(snapshot, runId) {
+  return selectApprovalsForRun(snapshot, runId).filter((approval) => approval.status === "pending");
+}
+function selectApprovalsForWorkspace(snapshot, workspaceId) {
+  if (!snapshot || !workspaceId)
+    return [];
+  const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
+  return snapshot.approvals.filter((approval) => runIds.has(approval.runId));
+}
+function selectUserInputsForRun(snapshot, runId) {
+  if (!runId)
+    return [];
+  return (snapshot?.userInputs ?? []).filter((request) => request.runId === runId);
+}
+function selectPendingUserInputs(snapshot) {
+  return (snapshot?.userInputs ?? []).filter((request) => request.status === "pending");
+}
+function selectPendingUserInputsForRun(snapshot, runId) {
+  return selectUserInputsForRun(snapshot, runId).filter((request) => request.status === "pending");
+}
+function selectUserInputsForWorkspace(snapshot, workspaceId) {
+  if (!snapshot || !workspaceId)
+    return [];
+  const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
+  return (snapshot.userInputs ?? []).filter((request) => runIds.has(request.runId));
+}
+function selectRuntimeForRun(snapshot, runId) {
+  if (!runId)
+    return null;
+  return snapshot?.runtimes.find((runtime) => runtime.runId === runId) ?? null;
+}
+function selectLatestRuntimeForTask(snapshot, taskId) {
+  if (!taskId)
+    return null;
+  const runs = selectRunsByTask(snapshot, taskId).toSorted((left, right) => (right.startedAt ?? right.createdAt).localeCompare(left.startedAt ?? left.createdAt));
+  for (const run of runs) {
+    const runtime = selectRuntimeForRun(snapshot, run.id);
+    if (runtime)
+      return runtime;
+  }
+  return null;
+}
+function selectActionsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return snapshot?.actions.filter((action) => runIds.has(action.runId)) ?? [];
+}
+function selectApprovalsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return snapshot?.approvals.filter((approval) => runIds.has(approval.runId)) ?? [];
+}
+function selectUserInputsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return (snapshot?.userInputs ?? []).filter((request) => runIds.has(request.runId));
+}
+function selectValidationsForRun(snapshot, runId) {
+  if (!runId)
+    return [];
+  return snapshot?.validations.filter((validation) => validation.runId === runId) ?? [];
+}
+function selectValidationsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return snapshot?.validations.filter((validation) => runIds.has(validation.runId)) ?? [];
+}
+function selectFailedValidations(snapshot, runId) {
+  return selectValidationsForRun(snapshot, runId).filter((validation) => validation.status === "failed");
+}
+function selectReviewsForRun(snapshot, runId) {
+  if (!runId)
+    return [];
+  return snapshot?.reviews.filter((review) => review.runId === runId) ?? [];
+}
+function selectReviewsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return snapshot?.reviews.filter((review) => runIds.has(review.runId)) ?? [];
+}
+function selectArtifactsForRun(snapshot, runId) {
+  if (!runId)
+    return [];
+  return snapshot?.artifacts.filter((artifact) => artifact.runId === runId) ?? [];
+}
+function selectArtifactsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return snapshot?.artifacts.filter((artifact) => runIds.has(artifact.runId)) ?? [];
+}
+function selectPolicyDecisionsForTask(snapshot, taskId) {
+  if (!taskId)
+    return [];
+  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
+  return snapshot?.policyDecisions.filter((decision) => runIds.has(decision.runId)) ?? [];
+}
+function selectRemoteEndpoints(snapshot) {
+  return snapshot?.remoteEndpoints ?? [];
+}
+function selectRemoteConnections(snapshot) {
+  return snapshot?.remoteConnections ?? [];
+}
+function selectRemoteEndpoint(snapshot, endpointId) {
+  if (!endpointId)
+    return null;
+  return snapshot?.remoteEndpoints.find((endpoint) => endpoint.id === endpointId) ?? null;
+}
+function selectRemoteConnection(snapshot, endpointId) {
+  if (!endpointId)
+    return null;
+  return snapshot?.remoteConnections.find((connection) => connection.endpointId === endpointId) ?? null;
+}
+function selectConnectedRemoteCount(snapshot) {
+  return selectRemoteConnections(snapshot).filter((connection) => connection.status === "connected").length;
+}
+export {
+  selectWorkspaces,
+  selectWorkspace,
+  selectValidationsForTask,
+  selectValidationsForRun,
+  selectUserInputsForWorkspace,
+  selectUserInputsForTask,
+  selectUserInputsForRun,
+  selectTasksGroupedByStatus,
+  selectTasksForWorkspace,
+  selectTasksByWorkspace,
+  selectTasksByStatus,
+  selectTask,
+  selectRuntimeForRun,
+  selectRunsForWorkspace,
+  selectRunsForTask,
+  selectRunsByTask,
+  selectRun,
+  selectReviewsForTask,
+  selectReviewsForRun,
+  selectRemoteEndpoints,
+  selectRemoteEndpoint,
+  selectRemoteConnections,
+  selectRemoteConnection,
+  selectQueueForWorkspace,
+  selectPrimaryWorkspace,
+  selectPolicyDecisionsForTask,
+  selectPendingUserInputsForRun,
+  selectPendingUserInputs,
+  selectPendingApprovalsForRun,
+  selectPendingApprovals,
+  selectLatestRuntimeForTask,
+  selectGraphsForWorkspace,
+  selectFailedValidations,
+  selectConnectedRemoteCount,
+  selectArtifactsForTask,
+  selectArtifactsForRun,
+  selectApprovalsForWorkspace,
+  selectApprovalsForTask,
+  selectApprovalsForRun,
+  selectAdhocRunsForWorkspace,
+  selectAdhocRuns,
+  selectActionsForTask,
+  pickDefaultWorkspaceId
+};

package/dist/src/taskGraph.js

@@ -0,0 +1,64 @@
+// @bun
+// packages/core/src/taskGraph.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readTaskMetadataStringList(task, key) {
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const value = metadata?.[key];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function readTaskSourceIssueId(task) {
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : null;
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskId, stack) => {
+    const cached = memo.get(taskId);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskId))
+      return 0;
+    const task = tasksById.get(taskId);
+    if (!task)
+      return 0;
+    stack.add(taskId);
+    const refs = [
+      ...readTaskMetadataStringList(task, "dependencies"),
+      ...readTaskMetadataStringList(task, "parentChildDeps")
+    ];
+    const blockers = refs.map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
+    stack.delete(taskId);
+    memo.set(taskId, depth);
+    return depth;
+  };
+  for (const task of tasks) {
+    visit(task.id, new Set);
+  }
+  return memo;
+}
+export {
+  resolveTaskReference,
+  readTaskSourceIssueId,
+  readTaskMetadataStringList,
+  computeTaskBlockingDepths,
+  buildTaskReferenceIndex
+};

package/dist/src/taskGraphCodes.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/core/src/taskGraphCodes.ts
+var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
+function extractTaskCode(title) {
+  const match = title.match(TASK_CODE_RE);
+  return match?.[1] ?? null;
+}
+function extractTaskGroupKey(title) {
+  const code = extractTaskCode(title);
+  if (!code)
+    return null;
+  const parts = code.split("-");
+  const suffix = parts.at(-1) ?? "";
+  if (/^\d+$/.test(suffix)) {
+    return parts.slice(0, -1).join("-");
+  }
+  return parts[0] ?? code;
+}
+function stripTaskCode(label) {
+  return label.replace(TASK_CODE_RE, "");
+}
+export {
+  stripTaskCode,
+  extractTaskGroupKey,
+  extractTaskCode
+};