@h-rig/planning-plugin 0.0.6-alpha.133

package/README.md

@@ -0,0 +1 @@
+# @h-rig/planning-plugin

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./planning";
+export * from "./plugin";

package/dist/src/index.js

@@ -0,0 +1,144 @@
+// @bun
+// packages/planning-plugin/src/planning.ts
+async function spec(input, ports) {
+  return ports.spec(input);
+}
+async function clarify(planSpec, context, ports) {
+  return ports.clarify(planSpec, context);
+}
+async function plan(planSpec, ports) {
+  return ports.plan(planSpec);
+}
+async function specClarifyPlan(input, context, ports) {
+  return plan(await clarify(await spec(input, ports), context, ports), ports);
+}
+function taskByLocalId(tasks) {
+  return new Map(tasks.map((task) => [task.localId, task]));
+}
+function topologicalTasks(tasks) {
+  const byLocalId = taskByLocalId(tasks);
+  const state = new Map;
+  const ordered = [];
+  const visit = (task, trail) => {
+    const current = state.get(task.localId);
+    if (current?.status === "visited")
+      return;
+    if (current?.status === "visiting")
+      throw new Error(`Planning task dependency cycle: ${[...trail, task.localId].join(" -> ")}`);
+    state.set(task.localId, { status: "visiting" });
+    const orderingRefs = task.parent ? [...task.dependsOn, task.parent] : task.dependsOn;
+    for (const dep of orderingRefs) {
+      const dependency = byLocalId.get(dep);
+      if (!dependency)
+        throw new Error(`Planning task ${task.localId} depends on missing task ${dep}`);
+      visit(dependency, [...trail, task.localId]);
+    }
+    state.set(task.localId, { status: "visited" });
+    ordered.push(task);
+  };
+  for (const task of tasks)
+    visit(task, []);
+  return ordered;
+}
+function recordValue(value, key) {
+  if (typeof value !== "object" || value === null || !(key in value))
+    return;
+  return value[key];
+}
+function planningMetadata(record) {
+  const metadata = recordValue(record, "metadata");
+  const rigPlanning = recordValue(metadata, "rigPlanning");
+  const localId = recordValue(rigPlanning, "localId");
+  const planId = recordValue(rigPlanning, "planId");
+  return {
+    ...typeof planId === "string" ? { planId } : {},
+    ...typeof localId === "string" ? { localId } : {}
+  };
+}
+function existingTasksByLocalId(records, planId) {
+  const entries = [];
+  for (const record of records) {
+    const metadata = planningMetadata(record);
+    if (metadata.localId && metadata.planId === planId)
+      entries.push([metadata.localId, record]);
+  }
+  return new Map(entries);
+}
+function taskBody(task) {
+  const acceptance = task.acceptance.length === 0 ? "- Complete the task as described." : task.acceptance.map((item) => `- ${item}`).join(`
+`);
+  const validation = task.validationKeys.length === 0 ? "- Project-specific validation." : task.validationKeys.map((item) => `- ${item}`).join(`
+`);
+  return [`${task.description}`, "", "Acceptance:", acceptance, "", "Validation:", validation].join(`
+`);
+}
+function createInputForTask(task, planId, localIdToTaskId) {
+  const deps = task.dependsOn.map((dep) => localIdToTaskId.get(dep) ?? dep);
+  const parents = task.parent ? [localIdToTaskId.get(task.parent) ?? task.parent] : [];
+  return {
+    title: task.title,
+    body: taskBody(task),
+    deps,
+    parents,
+    metadata: {
+      rigPlanning: {
+        planId,
+        localId: task.localId,
+        dependsOn: task.dependsOn,
+        parent: task.parent,
+        parallelizable: task.parallelizable,
+        scope: task.scope,
+        validationKeys: task.validationKeys
+      }
+    }
+  };
+}
+async function materialize(planSpec, source, options = {}) {
+  if (!source.create)
+    throw new Error("Task source does not support idempotent task creation.");
+  const planId = options.planId ?? planSpec.prdTitle;
+  const existingRecords = await source.list();
+  const existingByLocalId = existingTasksByLocalId(existingRecords, planId);
+  const localIdToTaskId = new Map;
+  const existing = [];
+  const created = [];
+  for (const task of topologicalTasks(planSpec.tasks)) {
+    const existingRecord = existingByLocalId.get(task.localId);
+    if (existingRecord) {
+      localIdToTaskId.set(task.localId, existingRecord.id);
+      existing.push({ localId: task.localId, taskId: existingRecord.id, created: false });
+      continue;
+    }
+    const record = await source.create(createInputForTask(task, planId, localIdToTaskId));
+    localIdToTaskId.set(task.localId, record.id);
+    created.push({ localId: task.localId, taskId: record.id, created: true });
+  }
+  return { planId, created, existing, localIdToTaskId: Object.fromEntries(localIdToTaskId) };
+}
+// packages/planning-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core";
+var PLANNING_PLUGIN_NAME = "@rig/planning-plugin";
+var planningPlugin = definePlugin({
+  name: PLANNING_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  provides: [],
+  requires: [],
+  contributes: {
+    cliCommands: [
+      {
+        id: "planning.materialize",
+        command: "rig plan materialize",
+        description: "Generate a plan from a PRD and materialize idempotent task-source tasks."
+      }
+    ]
+  }
+});
+export {
+  specClarifyPlan,
+  spec,
+  planningPlugin,
+  plan,
+  materialize,
+  clarify,
+  PLANNING_PLUGIN_NAME
+};

package/dist/src/planning.d.ts

@@ -0,0 +1,33 @@
+import type { PlanSpec, RegisteredTaskSource } from "@rig/contracts";
+export interface PrdInput {
+    readonly title: string;
+    readonly body: string;
+    readonly sourceRef?: string;
+}
+export interface PlanningProviderPorts {
+    spec(input: PrdInput): Promise<PlanSpec> | PlanSpec;
+    clarify(planSpec: PlanSpec, context: ClarificationContext): Promise<PlanSpec> | PlanSpec;
+    plan(planSpec: PlanSpec): Promise<PlanSpec> | PlanSpec;
+}
+export interface ClarificationContext {
+    readonly answers?: Readonly<Record<string, string>>;
+    readonly codeFacts?: readonly string[];
+}
+export interface MaterializedPlanTask {
+    readonly localId: string;
+    readonly taskId: string;
+    readonly created: boolean;
+}
+export interface MaterializePlanResult {
+    readonly planId: string;
+    readonly created: readonly MaterializedPlanTask[];
+    readonly existing: readonly MaterializedPlanTask[];
+    readonly localIdToTaskId: Readonly<Record<string, string>>;
+}
+export declare function spec(input: PrdInput, ports: Pick<PlanningProviderPorts, "spec">): Promise<PlanSpec>;
+export declare function clarify(planSpec: PlanSpec, context: ClarificationContext, ports: Pick<PlanningProviderPorts, "clarify">): Promise<PlanSpec>;
+export declare function plan(planSpec: PlanSpec, ports: Pick<PlanningProviderPorts, "plan">): Promise<PlanSpec>;
+export declare function specClarifyPlan(input: PrdInput, context: ClarificationContext, ports: PlanningProviderPorts): Promise<PlanSpec>;
+export declare function materialize(planSpec: PlanSpec, source: Pick<RegisteredTaskSource, "list" | "create">, options?: {
+    readonly planId?: string;
+}): Promise<MaterializePlanResult>;

package/dist/src/planning.js

@@ -0,0 +1,124 @@
+// @bun
+// packages/planning-plugin/src/planning.ts
+async function spec(input, ports) {
+  return ports.spec(input);
+}
+async function clarify(planSpec, context, ports) {
+  return ports.clarify(planSpec, context);
+}
+async function plan(planSpec, ports) {
+  return ports.plan(planSpec);
+}
+async function specClarifyPlan(input, context, ports) {
+  return plan(await clarify(await spec(input, ports), context, ports), ports);
+}
+function taskByLocalId(tasks) {
+  return new Map(tasks.map((task) => [task.localId, task]));
+}
+function topologicalTasks(tasks) {
+  const byLocalId = taskByLocalId(tasks);
+  const state = new Map;
+  const ordered = [];
+  const visit = (task, trail) => {
+    const current = state.get(task.localId);
+    if (current?.status === "visited")
+      return;
+    if (current?.status === "visiting")
+      throw new Error(`Planning task dependency cycle: ${[...trail, task.localId].join(" -> ")}`);
+    state.set(task.localId, { status: "visiting" });
+    const orderingRefs = task.parent ? [...task.dependsOn, task.parent] : task.dependsOn;
+    for (const dep of orderingRefs) {
+      const dependency = byLocalId.get(dep);
+      if (!dependency)
+        throw new Error(`Planning task ${task.localId} depends on missing task ${dep}`);
+      visit(dependency, [...trail, task.localId]);
+    }
+    state.set(task.localId, { status: "visited" });
+    ordered.push(task);
+  };
+  for (const task of tasks)
+    visit(task, []);
+  return ordered;
+}
+function recordValue(value, key) {
+  if (typeof value !== "object" || value === null || !(key in value))
+    return;
+  return value[key];
+}
+function planningMetadata(record) {
+  const metadata = recordValue(record, "metadata");
+  const rigPlanning = recordValue(metadata, "rigPlanning");
+  const localId = recordValue(rigPlanning, "localId");
+  const planId = recordValue(rigPlanning, "planId");
+  return {
+    ...typeof planId === "string" ? { planId } : {},
+    ...typeof localId === "string" ? { localId } : {}
+  };
+}
+function existingTasksByLocalId(records, planId) {
+  const entries = [];
+  for (const record of records) {
+    const metadata = planningMetadata(record);
+    if (metadata.localId && metadata.planId === planId)
+      entries.push([metadata.localId, record]);
+  }
+  return new Map(entries);
+}
+function taskBody(task) {
+  const acceptance = task.acceptance.length === 0 ? "- Complete the task as described." : task.acceptance.map((item) => `- ${item}`).join(`
+`);
+  const validation = task.validationKeys.length === 0 ? "- Project-specific validation." : task.validationKeys.map((item) => `- ${item}`).join(`
+`);
+  return [`${task.description}`, "", "Acceptance:", acceptance, "", "Validation:", validation].join(`
+`);
+}
+function createInputForTask(task, planId, localIdToTaskId) {
+  const deps = task.dependsOn.map((dep) => localIdToTaskId.get(dep) ?? dep);
+  const parents = task.parent ? [localIdToTaskId.get(task.parent) ?? task.parent] : [];
+  return {
+    title: task.title,
+    body: taskBody(task),
+    deps,
+    parents,
+    metadata: {
+      rigPlanning: {
+        planId,
+        localId: task.localId,
+        dependsOn: task.dependsOn,
+        parent: task.parent,
+        parallelizable: task.parallelizable,
+        scope: task.scope,
+        validationKeys: task.validationKeys
+      }
+    }
+  };
+}
+async function materialize(planSpec, source, options = {}) {
+  if (!source.create)
+    throw new Error("Task source does not support idempotent task creation.");
+  const planId = options.planId ?? planSpec.prdTitle;
+  const existingRecords = await source.list();
+  const existingByLocalId = existingTasksByLocalId(existingRecords, planId);
+  const localIdToTaskId = new Map;
+  const existing = [];
+  const created = [];
+  for (const task of topologicalTasks(planSpec.tasks)) {
+    const existingRecord = existingByLocalId.get(task.localId);
+    if (existingRecord) {
+      localIdToTaskId.set(task.localId, existingRecord.id);
+      existing.push({ localId: task.localId, taskId: existingRecord.id, created: false });
+      continue;
+    }
+    const record = await source.create(createInputForTask(task, planId, localIdToTaskId));
+    localIdToTaskId.set(task.localId, record.id);
+    created.push({ localId: task.localId, taskId: record.id, created: true });
+  }
+  return { planId, created, existing, localIdToTaskId: Object.fromEntries(localIdToTaskId) };
+}
+export {
+  specClarifyPlan,
+  spec,
+  plan,
+  materialize,
+  clarify
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,3 @@
+export declare const PLANNING_PLUGIN_NAME = "@rig/planning-plugin";
+export declare const planningPlugin: import("@rig/core").RigPluginWithRuntime;
+export default planningPlugin;

package/dist/src/plugin.js

@@ -0,0 +1,25 @@
+// @bun
+// packages/planning-plugin/src/plugin.ts
+import { definePlugin } from "@rig/core";
+var PLANNING_PLUGIN_NAME = "@rig/planning-plugin";
+var planningPlugin = definePlugin({
+  name: PLANNING_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  provides: [],
+  requires: [],
+  contributes: {
+    cliCommands: [
+      {
+        id: "planning.materialize",
+        command: "rig plan materialize",
+        description: "Generate a plan from a PRD and materialize idempotent task-source tasks."
+      }
+    ]
+  }
+});
+var plugin_default = planningPlugin;
+export {
+  planningPlugin,
+  plugin_default as default,
+  PLANNING_PLUGIN_NAME
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@h-rig/planning-plugin",
+  "version": "0.0.6-alpha.133",
+  "type": "module",
+  "description": "First-party PRD-to-plan plugin for Rig task sources.",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./planning": {
+      "types": "./dist/src/planning.d.ts",
+      "import": "./dist/src/planning.js"
+    },
+    "./plugin": {
+      "types": "./dist/src/plugin.d.ts",
+      "import": "./dist/src/plugin.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.133",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.133"
+  }
+}