@h-rig/planning-plugin 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/cli.js

@@ -18,6 +18,85 @@ async function specClarifyPlan(input, context, ports) {
   return plan(await clarify(await spec(input, ports), context, ports), ports);
 }
 
+// packages/planning-plugin/src/workspace-planning.ts
+function taskByLocalId(spec2) {
+  return new Map(spec2.tasks.map((task) => [task.localId, task]));
+}
+function planTaskCreationOrder(spec2) {
+  const tasks = taskByLocalId(spec2);
+  const visiting = new Set;
+  const visited = new Set;
+  const ordered = [];
+  const visit = (task, stack) => {
+    if (visited.has(task.localId))
+      return;
+    if (visiting.has(task.localId))
+      throw new Error(`Plan task cycle detected: ${[...stack, task.localId].join(" -> ")}`);
+    visiting.add(task.localId);
+    const refs = [...task.dependsOn, ...task.parent ? [task.parent] : []];
+    for (const ref of refs) {
+      const dependency = tasks.get(ref);
+      if (dependency)
+        visit(dependency, [...stack, task.localId]);
+    }
+    visiting.delete(task.localId);
+    visited.add(task.localId);
+    ordered.push(task);
+  };
+  for (const task of spec2.tasks)
+    visit(task, []);
+  return ordered;
+}
+function taskPayload(task, localIdToTaskId) {
+  return {
+    title: task.title,
+    description: task.description,
+    acceptance: [...task.acceptance],
+    scope: [...task.scope],
+    validationKeys: [...task.validationKeys],
+    dependencies: task.dependsOn.map((id) => localIdToTaskId.get(id) ?? id),
+    parent: task.parent ? localIdToTaskId.get(task.parent) ?? task.parent : null,
+    metadata: { localId: task.localId, parallelizable: task.parallelizable }
+  };
+}
+async function runPlanningDryRun(projectRoot, prd, deps, options = {}) {
+  return deps.generatePlan({ projectRoot, prd, ...options.title !== undefined ? { title: options.title } : {} });
+}
+async function materializePlanSpec(projectRoot, spec2, deps, options = {}) {
+  if (!deps.createTask)
+    throw new Error("materializePlanSpec requires createTask.");
+  const localIdToTaskId = new Map(options.existingLocalIdToTaskId ?? []);
+  const created = [];
+  for (const task of planTaskCreationOrder(spec2)) {
+    if (localIdToTaskId.has(task.localId))
+      continue;
+    const result = await deps.createTask(projectRoot, taskPayload(task, localIdToTaskId));
+    if (result.taskId)
+      localIdToTaskId.set(task.localId, result.taskId);
+    created.push({ localId: task.localId, taskId: result.taskId });
+  }
+  if (deps.updateTask) {
+    for (const task of spec2.tasks) {
+      const taskId = localIdToTaskId.get(task.localId);
+      if (!taskId)
+        continue;
+      await deps.updateTask(projectRoot, taskId, taskPayload(task, localIdToTaskId));
+    }
+  }
+  return {
+    created,
+    localIdToTaskId,
+    deferredQuestions: spec2.openQuestions.filter((question) => question.status === "deferred" || question.status === "open").map((question) => question.id)
+  };
+}
+async function planWorkspace(projectRoot, prd, deps, options = {}) {
+  const spec2 = await runPlanningDryRun(projectRoot, prd, deps, options.title !== undefined ? { title: options.title } : {});
+  return {
+    spec: spec2,
+    materialized: options.materialize ? await materializePlanSpec(projectRoot, spec2, deps, options.existingLocalIdToTaskId !== undefined ? { existingLocalIdToTaskId: options.existingLocalIdToTaskId } : {}) : null
+  };
+}
+
 // packages/planning-plugin/src/cli.ts
 var PLANNING_PLAN_CLI_ID = "planning.plan";
 function printJson(value) {
@@ -142,8 +221,9 @@ function defaultPlanningProvider(now) {
     plan: (planSpec) => planSpec
   };
 }
-async function loadPlanningClient() {
-  return await import("@rig/client");
+async function loadPlanningClientIo() {
+  const { createTask, getTask } = await import("@rig/core/task-io");
+  return { createTask, getTask };
 }
 async function readPrdText(context, args) {
   const title = takeOption(args, "--title");
@@ -154,7 +234,7 @@ async function readPrdText(context, args) {
   if (sources.length !== 1)
     throw new Error("rig plan requires exactly one of --text <prd>, --prd <file>, or --issue <id>.");
   if (issue.value) {
-    const { getTask } = await loadPlanningClient();
+    const { getTask } = await loadPlanningClientIo();
     const task = await getTask(context.projectRoot, issue.value);
     if (!task)
       throw new Error(`No task found for issue ${issue.value}.`);
@@ -180,7 +260,7 @@ async function executePlan(context, args) {
   const willMaterialize = materialize.value && !dryRun.value;
   const now = () => new Date().toISOString();
   const provider = defaultPlanningProvider(now);
-  const { createTask, planWorkspace } = await loadPlanningClient();
+  const { createTask } = await loadPlanningClientIo();
   const result = await planWorkspace(context.projectRoot, prd.body, {
     generatePlan: (input) => specClarifyPlan({ title: input.title ?? prd.title, body: input.prd }, {}, provider),
     createTask

package/dist/src/index.js

@@ -119,6 +119,87 @@ async function materialize(planSpec, source, options = {}) {
 }
 // packages/planning-plugin/src/cli.ts
 import { readFileSync } from "fs";
+
+// packages/planning-plugin/src/workspace-planning.ts
+function taskByLocalId2(spec2) {
+  return new Map(spec2.tasks.map((task) => [task.localId, task]));
+}
+function planTaskCreationOrder(spec2) {
+  const tasks = taskByLocalId2(spec2);
+  const visiting = new Set;
+  const visited = new Set;
+  const ordered = [];
+  const visit = (task, stack) => {
+    if (visited.has(task.localId))
+      return;
+    if (visiting.has(task.localId))
+      throw new Error(`Plan task cycle detected: ${[...stack, task.localId].join(" -> ")}`);
+    visiting.add(task.localId);
+    const refs = [...task.dependsOn, ...task.parent ? [task.parent] : []];
+    for (const ref of refs) {
+      const dependency = tasks.get(ref);
+      if (dependency)
+        visit(dependency, [...stack, task.localId]);
+    }
+    visiting.delete(task.localId);
+    visited.add(task.localId);
+    ordered.push(task);
+  };
+  for (const task of spec2.tasks)
+    visit(task, []);
+  return ordered;
+}
+function taskPayload(task, localIdToTaskId) {
+  return {
+    title: task.title,
+    description: task.description,
+    acceptance: [...task.acceptance],
+    scope: [...task.scope],
+    validationKeys: [...task.validationKeys],
+    dependencies: task.dependsOn.map((id) => localIdToTaskId.get(id) ?? id),
+    parent: task.parent ? localIdToTaskId.get(task.parent) ?? task.parent : null,
+    metadata: { localId: task.localId, parallelizable: task.parallelizable }
+  };
+}
+async function runPlanningDryRun(projectRoot, prd, deps, options = {}) {
+  return deps.generatePlan({ projectRoot, prd, ...options.title !== undefined ? { title: options.title } : {} });
+}
+async function materializePlanSpec(projectRoot, spec2, deps, options = {}) {
+  if (!deps.createTask)
+    throw new Error("materializePlanSpec requires createTask.");
+  const localIdToTaskId = new Map(options.existingLocalIdToTaskId ?? []);
+  const created = [];
+  for (const task of planTaskCreationOrder(spec2)) {
+    if (localIdToTaskId.has(task.localId))
+      continue;
+    const result = await deps.createTask(projectRoot, taskPayload(task, localIdToTaskId));
+    if (result.taskId)
+      localIdToTaskId.set(task.localId, result.taskId);
+    created.push({ localId: task.localId, taskId: result.taskId });
+  }
+  if (deps.updateTask) {
+    for (const task of spec2.tasks) {
+      const taskId = localIdToTaskId.get(task.localId);
+      if (!taskId)
+        continue;
+      await deps.updateTask(projectRoot, taskId, taskPayload(task, localIdToTaskId));
+    }
+  }
+  return {
+    created,
+    localIdToTaskId,
+    deferredQuestions: spec2.openQuestions.filter((question) => question.status === "deferred" || question.status === "open").map((question) => question.id)
+  };
+}
+async function planWorkspace(projectRoot, prd, deps, options = {}) {
+  const spec2 = await runPlanningDryRun(projectRoot, prd, deps, options.title !== undefined ? { title: options.title } : {});
+  return {
+    spec: spec2,
+    materialized: options.materialize ? await materializePlanSpec(projectRoot, spec2, deps, options.existingLocalIdToTaskId !== undefined ? { existingLocalIdToTaskId: options.existingLocalIdToTaskId } : {}) : null
+  };
+}
+
+// packages/planning-plugin/src/cli.ts
 var PLANNING_PLAN_CLI_ID = "planning.plan";
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
@@ -242,8 +323,9 @@ function defaultPlanningProvider(now) {
     plan: (planSpec) => planSpec
   };
 }
-async function loadPlanningClient() {
-  return await import("@rig/client");
+async function loadPlanningClientIo() {
+  const { createTask, getTask } = await import("@rig/core/task-io");
+  return { createTask, getTask };
 }
 async function readPrdText(context, args) {
   const title = takeOption(args, "--title");
@@ -254,7 +336,7 @@ async function readPrdText(context, args) {
   if (sources.length !== 1)
     throw new Error("rig plan requires exactly one of --text <prd>, --prd <file>, or --issue <id>.");
   if (issue.value) {
-    const { getTask } = await loadPlanningClient();
+    const { getTask } = await loadPlanningClientIo();
     const task = await getTask(context.projectRoot, issue.value);
     if (!task)
       throw new Error(`No task found for issue ${issue.value}.`);
@@ -280,7 +362,7 @@ async function executePlan(context, args) {
   const willMaterialize = materialize2.value && !dryRun.value;
   const now = () => new Date().toISOString();
   const provider = defaultPlanningProvider(now);
-  const { createTask, planWorkspace } = await loadPlanningClient();
+  const { createTask } = await loadPlanningClientIo();
   const result = await planWorkspace(context.projectRoot, prd.body, {
     generatePlan: (input) => specClarifyPlan({ title: input.title ?? prd.title, body: input.prd }, {}, provider),
     createTask
@@ -321,13 +403,8 @@ var planningPlugin = definePlugin({
     panels: [
       { id: PLANNING_PLAN_PANEL_ID, slot: "capability", title: "Plan intake", capabilityId: "planning.plan" }
     ],
-    cliCommands: planningCliCommands.map(({ run: _run, ...metadata }) => metadata)
+    cliCommands: planningCliCommands
   }
-}, {
-  featureCapabilities: [
-    { id: "planning.plan", title: "PRD-to-task planning", commandId: PLANNING_PLAN_CLI_ID, panelId: PLANNING_PLAN_PANEL_ID }
-  ],
-  cliCommands: planningCliCommands
 });
 function createPlanningPlugin() {
   return planningPlugin;

package/dist/src/plugin.d.ts

@@ -1,5 +1,5 @@
 export declare const PLANNING_PLUGIN_NAME = "@rig/planning-plugin";
 export declare const PLANNING_PLAN_PANEL_ID = "plan-intake";
-export declare const planningPlugin: import("@rig/core").RigPluginWithRuntime;
-export declare function createPlanningPlugin(): import("@rig/core").RigPluginWithRuntime;
+export declare const planningPlugin: import("@rig/core/config").RigPlugin;
+export declare function createPlanningPlugin(): import("@rig/core/config").RigPlugin;
 export default planningPlugin;

package/dist/src/plugin.js

@@ -21,6 +21,85 @@ async function specClarifyPlan(input, context, ports) {
   return plan(await clarify(await spec(input, ports), context, ports), ports);
 }
 
+// packages/planning-plugin/src/workspace-planning.ts
+function taskByLocalId(spec2) {
+  return new Map(spec2.tasks.map((task) => [task.localId, task]));
+}
+function planTaskCreationOrder(spec2) {
+  const tasks = taskByLocalId(spec2);
+  const visiting = new Set;
+  const visited = new Set;
+  const ordered = [];
+  const visit = (task, stack) => {
+    if (visited.has(task.localId))
+      return;
+    if (visiting.has(task.localId))
+      throw new Error(`Plan task cycle detected: ${[...stack, task.localId].join(" -> ")}`);
+    visiting.add(task.localId);
+    const refs = [...task.dependsOn, ...task.parent ? [task.parent] : []];
+    for (const ref of refs) {
+      const dependency = tasks.get(ref);
+      if (dependency)
+        visit(dependency, [...stack, task.localId]);
+    }
+    visiting.delete(task.localId);
+    visited.add(task.localId);
+    ordered.push(task);
+  };
+  for (const task of spec2.tasks)
+    visit(task, []);
+  return ordered;
+}
+function taskPayload(task, localIdToTaskId) {
+  return {
+    title: task.title,
+    description: task.description,
+    acceptance: [...task.acceptance],
+    scope: [...task.scope],
+    validationKeys: [...task.validationKeys],
+    dependencies: task.dependsOn.map((id) => localIdToTaskId.get(id) ?? id),
+    parent: task.parent ? localIdToTaskId.get(task.parent) ?? task.parent : null,
+    metadata: { localId: task.localId, parallelizable: task.parallelizable }
+  };
+}
+async function runPlanningDryRun(projectRoot, prd, deps, options = {}) {
+  return deps.generatePlan({ projectRoot, prd, ...options.title !== undefined ? { title: options.title } : {} });
+}
+async function materializePlanSpec(projectRoot, spec2, deps, options = {}) {
+  if (!deps.createTask)
+    throw new Error("materializePlanSpec requires createTask.");
+  const localIdToTaskId = new Map(options.existingLocalIdToTaskId ?? []);
+  const created = [];
+  for (const task of planTaskCreationOrder(spec2)) {
+    if (localIdToTaskId.has(task.localId))
+      continue;
+    const result = await deps.createTask(projectRoot, taskPayload(task, localIdToTaskId));
+    if (result.taskId)
+      localIdToTaskId.set(task.localId, result.taskId);
+    created.push({ localId: task.localId, taskId: result.taskId });
+  }
+  if (deps.updateTask) {
+    for (const task of spec2.tasks) {
+      const taskId = localIdToTaskId.get(task.localId);
+      if (!taskId)
+        continue;
+      await deps.updateTask(projectRoot, taskId, taskPayload(task, localIdToTaskId));
+    }
+  }
+  return {
+    created,
+    localIdToTaskId,
+    deferredQuestions: spec2.openQuestions.filter((question) => question.status === "deferred" || question.status === "open").map((question) => question.id)
+  };
+}
+async function planWorkspace(projectRoot, prd, deps, options = {}) {
+  const spec2 = await runPlanningDryRun(projectRoot, prd, deps, options.title !== undefined ? { title: options.title } : {});
+  return {
+    spec: spec2,
+    materialized: options.materialize ? await materializePlanSpec(projectRoot, spec2, deps, options.existingLocalIdToTaskId !== undefined ? { existingLocalIdToTaskId: options.existingLocalIdToTaskId } : {}) : null
+  };
+}
+
 // packages/planning-plugin/src/cli.ts
 var PLANNING_PLAN_CLI_ID = "planning.plan";
 function printJson(value) {
@@ -145,8 +224,9 @@ function defaultPlanningProvider(now) {
     plan: (planSpec) => planSpec
   };
 }
-async function loadPlanningClient() {
-  return await import("@rig/client");
+async function loadPlanningClientIo() {
+  const { createTask, getTask } = await import("@rig/core/task-io");
+  return { createTask, getTask };
 }
 async function readPrdText(context, args) {
   const title = takeOption(args, "--title");
@@ -157,7 +237,7 @@ async function readPrdText(context, args) {
   if (sources.length !== 1)
     throw new Error("rig plan requires exactly one of --text <prd>, --prd <file>, or --issue <id>.");
   if (issue.value) {
-    const { getTask } = await loadPlanningClient();
+    const { getTask } = await loadPlanningClientIo();
     const task = await getTask(context.projectRoot, issue.value);
     if (!task)
       throw new Error(`No task found for issue ${issue.value}.`);
@@ -183,7 +263,7 @@ async function executePlan(context, args) {
   const willMaterialize = materialize.value && !dryRun.value;
   const now = () => new Date().toISOString();
   const provider = defaultPlanningProvider(now);
-  const { createTask, planWorkspace } = await loadPlanningClient();
+  const { createTask } = await loadPlanningClientIo();
   const result = await planWorkspace(context.projectRoot, prd.body, {
     generatePlan: (input) => specClarifyPlan({ title: input.title ?? prd.title, body: input.prd }, {}, provider),
     createTask
@@ -224,13 +304,8 @@ var planningPlugin = definePlugin({
     panels: [
       { id: PLANNING_PLAN_PANEL_ID, slot: "capability", title: "Plan intake", capabilityId: "planning.plan" }
     ],
-    cliCommands: planningCliCommands.map(({ run: _run, ...metadata }) => metadata)
+    cliCommands: planningCliCommands
   }
-}, {
-  featureCapabilities: [
-    { id: "planning.plan", title: "PRD-to-task planning", commandId: PLANNING_PLAN_CLI_ID, panelId: PLANNING_PLAN_PANEL_ID }
-  ],
-  cliCommands: planningCliCommands
 });
 function createPlanningPlugin() {
   return planningPlugin;

package/dist/src/workspace-planning.d.ts

@@ -0,0 +1,39 @@
+import type { PlanSpec, PlanTask } from "@rig/contracts";
+export interface PlanningDeps {
+    readonly generatePlan: (input: PlanningInput) => Promise<PlanSpec> | PlanSpec;
+    readonly createTask?: (projectRoot: string, task: Record<string, unknown>) => Promise<{
+        readonly taskId: string | null;
+        readonly result?: unknown;
+    }>;
+    readonly updateTask?: (projectRoot: string, taskId: string, patch: Record<string, unknown>) => Promise<unknown>;
+    readonly now?: () => string;
+}
+export interface PlanningInput {
+    readonly projectRoot: string;
+    readonly prd: string;
+    readonly title?: string;
+}
+export interface WorkspaceMaterializePlanResult {
+    readonly created: readonly {
+        readonly localId: string;
+        readonly taskId: string | null;
+    }[];
+    readonly localIdToTaskId: ReadonlyMap<string, string>;
+    readonly deferredQuestions: readonly string[];
+}
+export interface PlanWorkspaceResult {
+    readonly spec: PlanSpec;
+    readonly materialized: WorkspaceMaterializePlanResult | null;
+}
+export declare function planTaskCreationOrder(spec: PlanSpec): readonly PlanTask[];
+export declare function runPlanningDryRun(projectRoot: string, prd: string, deps: Pick<PlanningDeps, "generatePlan">, options?: {
+    readonly title?: string;
+}): Promise<PlanSpec>;
+export declare function materializePlanSpec(projectRoot: string, spec: PlanSpec, deps: Pick<PlanningDeps, "createTask" | "updateTask">, options?: {
+    readonly existingLocalIdToTaskId?: ReadonlyMap<string, string>;
+}): Promise<WorkspaceMaterializePlanResult>;
+export declare function planWorkspace(projectRoot: string, prd: string, deps: PlanningDeps, options?: {
+    readonly title?: string;
+    readonly materialize?: boolean;
+    readonly existingLocalIdToTaskId?: ReadonlyMap<string, string>;
+}): Promise<PlanWorkspaceResult>;

package/dist/src/workspace-planning.js

@@ -0,0 +1,85 @@
+// @bun
+// packages/planning-plugin/src/workspace-planning.ts
+function taskByLocalId(spec) {
+  return new Map(spec.tasks.map((task) => [task.localId, task]));
+}
+function planTaskCreationOrder(spec) {
+  const tasks = taskByLocalId(spec);
+  const visiting = new Set;
+  const visited = new Set;
+  const ordered = [];
+  const visit = (task, stack) => {
+    if (visited.has(task.localId))
+      return;
+    if (visiting.has(task.localId))
+      throw new Error(`Plan task cycle detected: ${[...stack, task.localId].join(" -> ")}`);
+    visiting.add(task.localId);
+    const refs = [...task.dependsOn, ...task.parent ? [task.parent] : []];
+    for (const ref of refs) {
+      const dependency = tasks.get(ref);
+      if (dependency)
+        visit(dependency, [...stack, task.localId]);
+    }
+    visiting.delete(task.localId);
+    visited.add(task.localId);
+    ordered.push(task);
+  };
+  for (const task of spec.tasks)
+    visit(task, []);
+  return ordered;
+}
+function taskPayload(task, localIdToTaskId) {
+  return {
+    title: task.title,
+    description: task.description,
+    acceptance: [...task.acceptance],
+    scope: [...task.scope],
+    validationKeys: [...task.validationKeys],
+    dependencies: task.dependsOn.map((id) => localIdToTaskId.get(id) ?? id),
+    parent: task.parent ? localIdToTaskId.get(task.parent) ?? task.parent : null,
+    metadata: { localId: task.localId, parallelizable: task.parallelizable }
+  };
+}
+async function runPlanningDryRun(projectRoot, prd, deps, options = {}) {
+  return deps.generatePlan({ projectRoot, prd, ...options.title !== undefined ? { title: options.title } : {} });
+}
+async function materializePlanSpec(projectRoot, spec, deps, options = {}) {
+  if (!deps.createTask)
+    throw new Error("materializePlanSpec requires createTask.");
+  const localIdToTaskId = new Map(options.existingLocalIdToTaskId ?? []);
+  const created = [];
+  for (const task of planTaskCreationOrder(spec)) {
+    if (localIdToTaskId.has(task.localId))
+      continue;
+    const result = await deps.createTask(projectRoot, taskPayload(task, localIdToTaskId));
+    if (result.taskId)
+      localIdToTaskId.set(task.localId, result.taskId);
+    created.push({ localId: task.localId, taskId: result.taskId });
+  }
+  if (deps.updateTask) {
+    for (const task of spec.tasks) {
+      const taskId = localIdToTaskId.get(task.localId);
+      if (!taskId)
+        continue;
+      await deps.updateTask(projectRoot, taskId, taskPayload(task, localIdToTaskId));
+    }
+  }
+  return {
+    created,
+    localIdToTaskId,
+    deferredQuestions: spec.openQuestions.filter((question) => question.status === "deferred" || question.status === "open").map((question) => question.id)
+  };
+}
+async function planWorkspace(projectRoot, prd, deps, options = {}) {
+  const spec = await runPlanningDryRun(projectRoot, prd, deps, options.title !== undefined ? { title: options.title } : {});
+  return {
+    spec,
+    materialized: options.materialize ? await materializePlanSpec(projectRoot, spec, deps, options.existingLocalIdToTaskId !== undefined ? { existingLocalIdToTaskId: options.existingLocalIdToTaskId } : {}) : null
+  };
+}
+export {
+  runPlanningDryRun,
+  planWorkspace,
+  planTaskCreationOrder,
+  materializePlanSpec
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/planning-plugin",
-  "version": "0.0.6-alpha.155",
+  "version": "0.0.6-alpha.156",
   "type": "module",
   "description": "First-party PRD-to-plan plugin for Rig task sources.",
   "license": "UNLICENSED",
@@ -29,8 +29,7 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/client": "npm:@h-rig/client@0.0.6-alpha.155",
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.155",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.155"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.156",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.156"
   }
 }