@h-rig/planning-plugin 0.0.6-alpha.135 → 0.0.6-alpha.137

package/dist/src/cli.d.ts

@@ -0,0 +1,19 @@
+import type { RuntimeCliContext } from "@rig/core";
+export declare const PLANNING_PLAN_CLI_ID = "planning.plan";
+type CommandOutcome = {
+    readonly ok: boolean;
+    readonly group: string;
+    readonly command: string;
+    readonly details?: Record<string, unknown>;
+};
+export declare function executePlan(context: RuntimeCliContext, args: readonly string[]): Promise<CommandOutcome>;
+export declare const planningCliCommands: readonly [{
+    readonly id: "planning.plan";
+    readonly family: "plan";
+    readonly command: "rig plan --text <prd>|--prd <file>";
+    readonly description: "Generate a plan from a PRD and optionally materialize task-source tasks.";
+    readonly usage: "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]";
+    readonly projectRequired: true;
+    readonly run: typeof executePlan;
+}];
+export {};

package/dist/src/cli.js

@@ -0,0 +1,125 @@
+// @bun
+// packages/planning-plugin/src/cli.ts
+import { readFileSync } from "fs";
+import { createTask, planWorkspace } from "@rig/client";
+
+// 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);
+}
+
+// packages/planning-plugin/src/cli.ts
+var PLANNING_PLAN_CLI_ID = "planning.plan";
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function takeFlag(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { value: false, rest };
+  rest.splice(index, 1);
+  return { value: true, rest };
+}
+function takeOption(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { rest };
+  const value = rest[index + 1];
+  if (!value || value.startsWith("-"))
+    throw new Error(`${flag} requires a value.`);
+  rest.splice(index, 2);
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0)
+    throw new Error(`Unexpected argument: ${args[0]}
+Usage: ${usage}`);
+}
+function defaultPlanningProvider(now) {
+  return {
+    spec: (input) => {
+      const headings = input.body.split(/\r?\n/).map((line) => line.match(/^#{1,3}\s+(.+)$/)?.[1]?.trim()).filter((line) => Boolean(line));
+      const titles = headings.length > 0 ? headings : [input.title];
+      return {
+        prdTitle: input.title,
+        userStories: [],
+        functionalRequirements: [],
+        openQuestions: [],
+        tasks: titles.map((title, index) => ({
+          localId: `task-${index + 1}`,
+          title,
+          description: `Implement: ${title}`,
+          acceptance: [],
+          scope: [],
+          validationKeys: [],
+          dependsOn: index === 0 ? [] : [`task-${index}`],
+          parent: null,
+          parallelizable: index === 0
+        })),
+        generatedAt: now()
+      };
+    },
+    clarify: (planSpec) => planSpec,
+    plan: (planSpec) => planSpec
+  };
+}
+function readPrdText(args) {
+  const title = takeOption(args, "--title");
+  const text = takeOption(title.rest, "--text");
+  const prd = takeOption(text.rest, "--prd");
+  const body = text.value ?? (prd.value ? readFileSync(prd.value, "utf8") : null);
+  if (!body?.trim())
+    throw new Error("rig plan requires --text <prd> or --prd <file>.");
+  return { title: title.value?.trim() || "Rig generated plan", body, rest: prd.rest };
+}
+async function executePlan(context, args) {
+  const materialize = takeFlag(args, "--materialize");
+  const dryRun = takeFlag(materialize.rest, "--dry-run");
+  const json = takeFlag(dryRun.rest, "--json");
+  if (materialize.value && dryRun.value)
+    throw new Error("Pass only one of --materialize or --dry-run.");
+  const prd = readPrdText(json.rest);
+  requireNoExtraArgs(prd.rest, "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]");
+  const willMaterialize = materialize.value && !dryRun.value;
+  const now = () => new Date().toISOString();
+  const provider = defaultPlanningProvider(now);
+  const result = await planWorkspace(context.projectRoot, prd.body, {
+    generatePlan: (input) => specClarifyPlan({ title: input.title ?? prd.title, body: input.prd }, {}, provider),
+    createTask
+  }, { title: prd.title, materialize: willMaterialize });
+  if (context.outputMode === "text") {
+    if (json.value)
+      printJson(result);
+    else
+      console.log(result.spec.tasks.map((task) => `${task.localId}	${task.title}`).join(`
+`) || "No plan tasks.");
+  }
+  return { ok: true, group: "plan", command: willMaterialize ? "materialize" : "show", details: result };
+}
+var planningCliCommands = [
+  {
+    id: PLANNING_PLAN_CLI_ID,
+    family: "plan",
+    command: "rig plan --text <prd>|--prd <file>",
+    description: "Generate a plan from a PRD and optionally materialize task-source tasks.",
+    usage: "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]",
+    projectRequired: true,
+    run: executePlan
+  }
+];
+export {
+  planningCliCommands,
+  executePlan,
+  PLANNING_PLAN_CLI_ID
+};

package/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -115,30 +115,147 @@ async function materialize(planSpec, source, options = {}) {
   }
   return { planId, created, existing, localIdToTaskId: Object.fromEntries(localIdToTaskId) };
 }
+// packages/planning-plugin/src/cli.ts
+import { readFileSync } from "fs";
+import { createTask, planWorkspace } from "@rig/client";
+var PLANNING_PLAN_CLI_ID = "planning.plan";
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function takeFlag(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { value: false, rest };
+  rest.splice(index, 1);
+  return { value: true, rest };
+}
+function takeOption(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { rest };
+  const value = rest[index + 1];
+  if (!value || value.startsWith("-"))
+    throw new Error(`${flag} requires a value.`);
+  rest.splice(index, 2);
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0)
+    throw new Error(`Unexpected argument: ${args[0]}
+Usage: ${usage}`);
+}
+function defaultPlanningProvider(now) {
+  return {
+    spec: (input) => {
+      const headings = input.body.split(/\r?\n/).map((line) => line.match(/^#{1,3}\s+(.+)$/)?.[1]?.trim()).filter((line) => Boolean(line));
+      const titles = headings.length > 0 ? headings : [input.title];
+      return {
+        prdTitle: input.title,
+        userStories: [],
+        functionalRequirements: [],
+        openQuestions: [],
+        tasks: titles.map((title, index) => ({
+          localId: `task-${index + 1}`,
+          title,
+          description: `Implement: ${title}`,
+          acceptance: [],
+          scope: [],
+          validationKeys: [],
+          dependsOn: index === 0 ? [] : [`task-${index}`],
+          parent: null,
+          parallelizable: index === 0
+        })),
+        generatedAt: now()
+      };
+    },
+    clarify: (planSpec) => planSpec,
+    plan: (planSpec) => planSpec
+  };
+}
+function readPrdText(args) {
+  const title = takeOption(args, "--title");
+  const text = takeOption(title.rest, "--text");
+  const prd = takeOption(text.rest, "--prd");
+  const body = text.value ?? (prd.value ? readFileSync(prd.value, "utf8") : null);
+  if (!body?.trim())
+    throw new Error("rig plan requires --text <prd> or --prd <file>.");
+  return { title: title.value?.trim() || "Rig generated plan", body, rest: prd.rest };
+}
+async function executePlan(context, args) {
+  const materialize2 = takeFlag(args, "--materialize");
+  const dryRun = takeFlag(materialize2.rest, "--dry-run");
+  const json = takeFlag(dryRun.rest, "--json");
+  if (materialize2.value && dryRun.value)
+    throw new Error("Pass only one of --materialize or --dry-run.");
+  const prd = readPrdText(json.rest);
+  requireNoExtraArgs(prd.rest, "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]");
+  const willMaterialize = materialize2.value && !dryRun.value;
+  const now = () => new Date().toISOString();
+  const provider = defaultPlanningProvider(now);
+  const result = await planWorkspace(context.projectRoot, prd.body, {
+    generatePlan: (input) => specClarifyPlan({ title: input.title ?? prd.title, body: input.prd }, {}, provider),
+    createTask
+  }, { title: prd.title, materialize: willMaterialize });
+  if (context.outputMode === "text") {
+    if (json.value)
+      printJson(result);
+    else
+      console.log(result.spec.tasks.map((task) => `${task.localId}	${task.title}`).join(`
+`) || "No plan tasks.");
+  }
+  return { ok: true, group: "plan", command: willMaterialize ? "materialize" : "show", details: result };
+}
+var planningCliCommands = [
+  {
+    id: PLANNING_PLAN_CLI_ID,
+    family: "plan",
+    command: "rig plan --text <prd>|--prd <file>",
+    description: "Generate a plan from a PRD and optionally materialize task-source tasks.",
+    usage: "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]",
+    projectRequired: true,
+    run: executePlan
+  }
+];
 // packages/planning-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core";
 var PLANNING_PLUGIN_NAME = "@rig/planning-plugin";
+var PLANNING_PLAN_PANEL_ID = "plan-intake";
 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."
-      }
-    ]
+    capabilities: [
+      { id: "planning.plan", title: "PRD-to-task planning", commandId: PLANNING_PLAN_CLI_ID, panelId: PLANNING_PLAN_PANEL_ID }
+    ],
+    panels: [
+      { id: PLANNING_PLAN_PANEL_ID, slot: "capability", title: "Plan intake", capabilityId: "planning.plan" }
+    ],
+    cliCommands: planningCliCommands.map(({ run: _run, ...metadata }) => metadata)
   }
+}, {
+  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;
+}
 export {
   specClarifyPlan,
   spec,
   planningPlugin,
+  planningCliCommands,
   plan,
   materialize,
+  executePlan,
+  createPlanningPlugin,
   clarify,
-  PLANNING_PLUGIN_NAME
+  PLANNING_PLUGIN_NAME,
+  PLANNING_PLAN_PANEL_ID,
+  PLANNING_PLAN_CLI_ID
 };

package/dist/src/plugin.d.ts

@@ -1,3 +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 default planningPlugin;

package/dist/src/plugin.js

@@ -1,25 +1,158 @@
 // @bun
 // packages/planning-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core";
+
+// packages/planning-plugin/src/cli.ts
+import { readFileSync } from "fs";
+import { createTask, planWorkspace } from "@rig/client";
+
+// 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);
+}
+
+// packages/planning-plugin/src/cli.ts
+var PLANNING_PLAN_CLI_ID = "planning.plan";
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function takeFlag(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { value: false, rest };
+  rest.splice(index, 1);
+  return { value: true, rest };
+}
+function takeOption(args, flag) {
+  const rest = [...args];
+  const index = rest.indexOf(flag);
+  if (index < 0)
+    return { rest };
+  const value = rest[index + 1];
+  if (!value || value.startsWith("-"))
+    throw new Error(`${flag} requires a value.`);
+  rest.splice(index, 2);
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0)
+    throw new Error(`Unexpected argument: ${args[0]}
+Usage: ${usage}`);
+}
+function defaultPlanningProvider(now) {
+  return {
+    spec: (input) => {
+      const headings = input.body.split(/\r?\n/).map((line) => line.match(/^#{1,3}\s+(.+)$/)?.[1]?.trim()).filter((line) => Boolean(line));
+      const titles = headings.length > 0 ? headings : [input.title];
+      return {
+        prdTitle: input.title,
+        userStories: [],
+        functionalRequirements: [],
+        openQuestions: [],
+        tasks: titles.map((title, index) => ({
+          localId: `task-${index + 1}`,
+          title,
+          description: `Implement: ${title}`,
+          acceptance: [],
+          scope: [],
+          validationKeys: [],
+          dependsOn: index === 0 ? [] : [`task-${index}`],
+          parent: null,
+          parallelizable: index === 0
+        })),
+        generatedAt: now()
+      };
+    },
+    clarify: (planSpec) => planSpec,
+    plan: (planSpec) => planSpec
+  };
+}
+function readPrdText(args) {
+  const title = takeOption(args, "--title");
+  const text = takeOption(title.rest, "--text");
+  const prd = takeOption(text.rest, "--prd");
+  const body = text.value ?? (prd.value ? readFileSync(prd.value, "utf8") : null);
+  if (!body?.trim())
+    throw new Error("rig plan requires --text <prd> or --prd <file>.");
+  return { title: title.value?.trim() || "Rig generated plan", body, rest: prd.rest };
+}
+async function executePlan(context, args) {
+  const materialize = takeFlag(args, "--materialize");
+  const dryRun = takeFlag(materialize.rest, "--dry-run");
+  const json = takeFlag(dryRun.rest, "--json");
+  if (materialize.value && dryRun.value)
+    throw new Error("Pass only one of --materialize or --dry-run.");
+  const prd = readPrdText(json.rest);
+  requireNoExtraArgs(prd.rest, "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]");
+  const willMaterialize = materialize.value && !dryRun.value;
+  const now = () => new Date().toISOString();
+  const provider = defaultPlanningProvider(now);
+  const result = await planWorkspace(context.projectRoot, prd.body, {
+    generatePlan: (input) => specClarifyPlan({ title: input.title ?? prd.title, body: input.prd }, {}, provider),
+    createTask
+  }, { title: prd.title, materialize: willMaterialize });
+  if (context.outputMode === "text") {
+    if (json.value)
+      printJson(result);
+    else
+      console.log(result.spec.tasks.map((task) => `${task.localId}	${task.title}`).join(`
+`) || "No plan tasks.");
+  }
+  return { ok: true, group: "plan", command: willMaterialize ? "materialize" : "show", details: result };
+}
+var planningCliCommands = [
+  {
+    id: PLANNING_PLAN_CLI_ID,
+    family: "plan",
+    command: "rig plan --text <prd>|--prd <file>",
+    description: "Generate a plan from a PRD and optionally materialize task-source tasks.",
+    usage: "rig plan --text <prd>|--prd <file> [--title <title>] [--materialize|--dry-run] [--json]",
+    projectRequired: true,
+    run: executePlan
+  }
+];
+
+// packages/planning-plugin/src/plugin.ts
 var PLANNING_PLUGIN_NAME = "@rig/planning-plugin";
+var PLANNING_PLAN_PANEL_ID = "plan-intake";
 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."
-      }
-    ]
+    capabilities: [
+      { id: "planning.plan", title: "PRD-to-task planning", commandId: PLANNING_PLAN_CLI_ID, panelId: PLANNING_PLAN_PANEL_ID }
+    ],
+    panels: [
+      { id: PLANNING_PLAN_PANEL_ID, slot: "capability", title: "Plan intake", capabilityId: "planning.plan" }
+    ],
+    cliCommands: planningCliCommands.map(({ run: _run, ...metadata }) => metadata)
   }
+}, {
+  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;
+}
 var plugin_default = planningPlugin;
 export {
   planningPlugin,
   plugin_default as default,
-  PLANNING_PLUGIN_NAME
+  createPlanningPlugin,
+  PLANNING_PLUGIN_NAME,
+  PLANNING_PLAN_PANEL_ID
 };

package/package.json

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