@poetic-ai/poetic 1.42.0

package/dist/plan-backlog-show-fast-SG2CZPW3.js

@@ -0,0 +1,406 @@
+import {
+  getBacklogExecuteOperationalReadbackV1
+} from "./chunk-P5I4X7A7.js";
+import {
+  TaskIdSchema
+} from "./chunk-NP2V3L7K.js";
+import "./chunk-BLPHWMDK.js";
+import "./chunk-NM6PMYY4.js";
+import {
+  findParkingItem
+} from "./chunk-O47UOKU3.js";
+import {
+  formatDeclaredRelatedTaskLines,
+  formatLinkedTaskLines,
+  hasDeclaredRelatedTasks
+} from "./chunk-PKIFMV72.js";
+import {
+  findBacklogItem
+} from "./chunk-LH5QY22X.js";
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import "./chunk-LO3X5NLS.js";
+import "./chunk-6MFRHTRI.js";
+import "./chunk-RZY7RKM5.js";
+import "./chunk-P6VQROCO.js";
+import "./chunk-GG6KJYW6.js";
+import {
+  listTasksLinkedToBacklogItem
+} from "./chunk-5LTN43AS.js";
+import "./chunk-Y55LZN5U.js";
+import "./chunk-TDSEX5CF.js";
+import "./chunk-LIVJ6266.js";
+import "./chunk-7QCZSLBH.js";
+import "./chunk-VXF4Q3FW.js";
+import "./chunk-4RCCF5BR.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-KNT72VR6.js";
+import "./chunk-3BCUNHKF.js";
+import "./chunk-OYZYO7TV.js";
+import "./chunk-VNSYKC25.js";
+import "./chunk-R35PEUKH.js";
+import {
+  getPlanningRoot
+} from "./chunk-OPYFYTWQ.js";
+import "./chunk-UHT2KRG5.js";
+import "./chunk-DSFM56OA.js";
+import "./chunk-UGX7GI37.js";
+import {
+  getBucketPathByKind
+} from "./chunk-HOYBYAOA.js";
+import "./chunk-OIS7J26S.js";
+import "./chunk-CP7H3HSP.js";
+import "./chunk-UR2IBGIM.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-LO23NABI.js";
+import "./chunk-7R2WLDOS.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-ENRGKNR5.js";
+import {
+  createSafeErrorMessage
+} from "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/commands/plan-backlog-show-fast.ts
+import * as path from "path";
+import chalk from "chalk";
+import { Command } from "commander";
+function printBacklogShowJsonError(code, message, details) {
+  console.log(
+    JSON.stringify(
+      {
+        error: code,
+        message,
+        ...details ?? {}
+      },
+      null,
+      2
+    )
+  );
+}
+async function runPlanBacklogShowAction(id, options, getProjectRoot = getPlanningRoot) {
+  const projectRoot = getProjectRoot();
+  const backlogDir = getBucketPathByKind("backlog", projectRoot);
+  if (options.ids) {
+    if (id) {
+      if (options.json) {
+        printBacklogShowJsonError("invalid_arguments", "Cannot combine positional <id> with --ids");
+        throw new ExitCodeError(1);
+      }
+      console.error(chalk.red("Error Cannot combine positional <id> with --ids"));
+      console.error(
+        chalk.gray(
+          "Use either `poetic backlog show <id>` or `poetic backlog show --ids <id1,id2,...>`"
+        )
+      );
+      throw new ExitCodeError(1);
+    }
+    if (options.bodyOnly) {
+      if (options.json) {
+        printBacklogShowJsonError("invalid_arguments", "--body-only cannot be used with --ids");
+        throw new ExitCodeError(1);
+      }
+      console.error(chalk.red("Error --body-only cannot be used with --ids"));
+      throw new ExitCodeError(1);
+    }
+    const idList = options.ids.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (idList.length === 0) {
+      if (options.json) {
+        printBacklogShowJsonError("invalid_arguments", "--ids requires at least one ID");
+        throw new ExitCodeError(1);
+      }
+      console.error(chalk.red("Error --ids requires at least one ID"));
+      throw new ExitCodeError(1);
+    }
+    const results = [];
+    const missingIds = [];
+    const invalidIds = [];
+    for (const batchId of idList) {
+      const parsedId2 = TaskIdSchema.safeParse(batchId);
+      if (!parsedId2.success) {
+        invalidIds.push(batchId);
+        continue;
+      }
+      const safeId2 = parsedId2.data;
+      try {
+        const item2 = await findBacklogItem(backlogDir, safeId2);
+        if (item2) {
+          results.push({
+            id: item2.yaml.id,
+            title: item2.yaml.title,
+            status: item2.yaml.status,
+            priority: item2.yaml.priority ?? null,
+            complexity: item2.yaml.estimatedComplexity ?? null,
+            domain: item2.yaml.domain ?? null,
+            filePath: path.relative(projectRoot, item2.filePath),
+            body: item2.body
+          });
+          continue;
+        }
+        const parkingDir = getBucketPathByKind("parking-lot", projectRoot);
+        const parked2 = await findParkingItem(parkingDir, safeId2);
+        if (parked2) {
+          results.push({
+            id: parked2.yaml.id,
+            title: parked2.yaml.title,
+            status: `deferred (${parked2.yaml.status})`,
+            priority: null,
+            complexity: typeof parked2.yaml.estimatedComplexity === "number" ? parked2.yaml.estimatedComplexity : null,
+            domain: null,
+            filePath: path.relative(projectRoot, parked2.filePath),
+            body: parked2.body
+          });
+          continue;
+        }
+        missingIds.push(safeId2);
+      } catch {
+        missingIds.push(safeId2);
+      }
+    }
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            items: results,
+            missingIds,
+            invalidIds
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      for (const item2 of results) {
+        console.log(chalk.bold.cyan(`
+${item2.title}`));
+        console.log(
+          chalk.gray(
+            `  ID: ${item2.id}  Status: ${item2.status}  Priority: ${item2.priority ?? "none"}`
+          )
+        );
+        console.log(chalk.gray(`  File: ${item2.filePath}`));
+      }
+      if (results.length === 0) {
+        console.log(chalk.yellow("No items found for the given IDs."));
+      } else {
+        console.log(chalk.gray(`
+Total: ${results.length} item(s)
+`));
+      }
+      if (missingIds.length > 0) {
+        console.log(chalk.yellow(`Missing IDs: ${missingIds.join(", ")}`));
+      }
+      if (invalidIds.length > 0) {
+        console.log(chalk.yellow(`Invalid IDs: ${invalidIds.join(", ")}`));
+      }
+    }
+    return;
+  }
+  if (!id) {
+    if (options.json) {
+      printBacklogShowJsonError(
+        "missing_id",
+        "Please provide an item ID or use --ids for batch lookup"
+      );
+      throw new ExitCodeError(1);
+    }
+    console.error(chalk.red("Error Please provide an item ID or use --ids for batch lookup"));
+    console.error(
+      chalk.gray("\nUsage:\n  poetic backlog show <id>\n  poetic backlog show --ids <id1,id2,...>")
+    );
+    throw new ExitCodeError(1);
+  }
+  const parsedId = TaskIdSchema.safeParse(id);
+  if (!parsedId.success) {
+    if (options.json) {
+      printBacklogShowJsonError("invalid_id", `Invalid backlog item ID: ${id}`);
+      throw new ExitCodeError(1);
+    }
+    console.error(chalk.red(`Error Invalid backlog item ID: ${id}`));
+    throw new ExitCodeError(1);
+  }
+  const safeId = parsedId.data;
+  const item = await findBacklogItem(backlogDir, safeId);
+  let parked = null;
+  if (!item) {
+    const parkingDir = getBucketPathByKind("parking-lot", projectRoot);
+    parked = await findParkingItem(parkingDir, safeId);
+  }
+  if (!item && !parked) {
+    if (options.json) {
+      printBacklogShowJsonError("not_found", `Backlog item not found: ${safeId}`, {
+        id: safeId,
+        tip: "Use `poetic backlog list --json` to see available items"
+      });
+      throw new ExitCodeError(1);
+    }
+    console.error(chalk.red(`Error Backlog item not found: ${safeId}`));
+    console.error(
+      chalk.gray("\nTip: Use `poetic backlog list` (or `--status deferred`) to see available items")
+    );
+    throw new ExitCodeError(1);
+  }
+  if (options.bodyOnly) {
+    console.log((item ?? parked).body);
+    return;
+  }
+  let linkedTasks = [];
+  let declaredRelatedTasks;
+  if (item) {
+    linkedTasks = await listTasksLinkedToBacklogItem(safeId, { includeArchive: true });
+    declaredRelatedTasks = hasDeclaredRelatedTasks(item.yaml.relatedTasks) ? item.yaml.relatedTasks : void 0;
+    if (options.json) {
+      const jsonOutput = {
+        id: item.yaml.id,
+        title: item.yaml.title,
+        status: item.yaml.status,
+        priority: item.yaml.priority ?? null,
+        complexity: item.yaml.estimatedComplexity ?? null,
+        domain: item.yaml.domain ?? null,
+        createdAt: item.yaml.createdAt,
+        filePath: path.relative(projectRoot, item.filePath),
+        body: item.body,
+        runCommand: `poetic run --backlog-item ${safeId}`,
+        linkedTasks
+      };
+      if (declaredRelatedTasks) {
+        jsonOutput.relatedTasks = declaredRelatedTasks;
+      }
+      jsonOutput.operationalReadbackV1 = await getBacklogExecuteOperationalReadbackV1(safeId, {
+        projectRoot
+      });
+      console.log(JSON.stringify(jsonOutput, null, 2));
+      return;
+    }
+  } else if (parked) {
+    if (options.json) {
+      const jsonOutput = {
+        id: parked.yaml.id,
+        kind: "parking-lot",
+        title: parked.yaml.title,
+        status: parked.yaml.status,
+        deferralReason: parked.yaml.deferralReason ?? null,
+        reconsiderDate: parked.yaml.reconsiderDate ?? null,
+        originalStatus: parked.yaml.originalStatus ?? null,
+        createdAt: parked.yaml.createdAt ?? null,
+        filePath: path.relative(projectRoot, parked.filePath),
+        body: parked.body
+      };
+      console.log(JSON.stringify(jsonOutput, null, 2));
+      return;
+    }
+    console.log(chalk.bold.cyan(`
+${parked.yaml.title}
+`));
+    console.log(chalk.gray(`ID: ${parked.yaml.id}`));
+    console.log(chalk.gray("Kind: parking-lot"));
+    console.log(chalk.gray(`Status: ${parked.yaml.status}`));
+    if (parked.yaml.deferralReason) {
+      console.log(chalk.gray(`Reason: ${parked.yaml.deferralReason}`));
+    }
+    if (parked.yaml.reconsiderDate) {
+      console.log(chalk.gray(`Reconsider: ${parked.yaml.reconsiderDate}`));
+    }
+    console.log(chalk.gray(`File: ${path.relative(projectRoot, parked.filePath)}`));
+    console.log(chalk.gray("\n--- Body ---\n"));
+    console.log(parked.body);
+    console.log(chalk.cyan("\n--- To Reactivate ---\n"));
+    console.log(chalk.white(`  poetic backlog parking unpark ${safeId}`));
+    return;
+  }
+  console.log(chalk.bold.cyan(`
+${item.yaml.title}
+`));
+  console.log(chalk.gray(`ID: ${item.yaml.id}`));
+  console.log(chalk.gray(`Status: ${item.yaml.status}`));
+  if (item.yaml.priority) {
+    console.log(chalk.gray(`Priority: ${item.yaml.priority}`));
+  }
+  if (item.yaml.estimatedComplexity !== void 0) {
+    console.log(chalk.gray(`Complexity: ${item.yaml.estimatedComplexity}`));
+  }
+  if (item.yaml.domain) {
+    console.log(chalk.gray(`Domain: ${item.yaml.domain}`));
+  }
+  console.log(chalk.gray(`File: ${path.relative(projectRoot, item.filePath)}`));
+  if (declaredRelatedTasks) {
+    console.log(chalk.gray("\n--- Related tasks (declared) ---"));
+    for (const line of formatDeclaredRelatedTaskLines(declaredRelatedTasks)) {
+      console.log(chalk.gray(line));
+    }
+  }
+  if (linkedTasks.length > 0) {
+    console.log(chalk.gray("\n--- Linked tasks (computed) ---"));
+    for (const line of formatLinkedTaskLines(linkedTasks)) {
+      console.log(chalk.gray(line));
+    }
+  }
+  console.log(chalk.gray("\n--- Body ---\n"));
+  console.log(item.body);
+  console.log(chalk.cyan("\n--- Beta path (no remote needed) ---\n"));
+  console.log(chalk.white(`  poetic run --backlog-item ${safeId}`));
+  console.log(chalk.cyan("\n--- To Execute (canonical; advanced; requires a git remote) ---\n"));
+  console.log(chalk.white(`  poetic backlog execute ${safeId}`));
+  console.log(
+    chalk.gray("    Use --review-only (or --dry-run) to validate readiness without executing.")
+  );
+  console.log(chalk.white(`  poetic backlog finalize ${safeId} --pr <n> --commit <sha>`));
+  console.log(chalk.gray("\n--- Alternatives (no execution provenance) ---\n"));
+  console.log(
+    chalk.gray(`  poetic compete --backlog-item ${safeId} --variant <provider>:<strategy>`)
+  );
+  console.log(chalk.gray(`  poetic run --task-file ${path.relative(projectRoot, item.filePath)}`));
+}
+function createPlanBacklogShowFastCommand(getProjectRoot = getPlanningRoot) {
+  const plan = new Command("plan").alias("pl").description("Work definition and organization");
+  const backlog = new Command("backlog").description("Manage backlog items");
+  backlog.command("show [id]").description("View backlog item details").option("--json", "Output as JSON").option("--body-only", "Output only the markdown body").option("--ids <list>", "Comma-separated IDs for batch lookup").action(
+    async (id, options) => {
+      try {
+        await runPlanBacklogShowAction(id, options, getProjectRoot);
+      } catch (error) {
+        if (error instanceof ExitCodeError) {
+          throw error;
+        }
+        console.error(chalk.red("Error Failed to show item:"));
+        console.error(createSafeErrorMessage(error, "backlog show"));
+        throw new ExitCodeError(1);
+      }
+    }
+  );
+  plan.addCommand(backlog);
+  return plan;
+}
+export {
+  createPlanBacklogShowFastCommand,
+  runPlanBacklogShowAction
+};
+//# sourceMappingURL=plan-backlog-show-fast-SG2CZPW3.js.map

package/dist/plan-sprint-list-fast-LURAX47V.js

@@ -0,0 +1,162 @@
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  listSprints
+} from "./chunk-4YX7J6QL.js";
+import "./chunk-P7CQGPLS.js";
+import "./chunk-KNT72VR6.js";
+import "./chunk-3BCUNHKF.js";
+import "./chunk-OYZYO7TV.js";
+import "./chunk-VNSYKC25.js";
+import "./chunk-R35PEUKH.js";
+import "./chunk-OPYFYTWQ.js";
+import "./chunk-UHT2KRG5.js";
+import "./chunk-DSFM56OA.js";
+import "./chunk-UGX7GI37.js";
+import "./chunk-HOYBYAOA.js";
+import "./chunk-OIS7J26S.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-LO23NABI.js";
+import "./chunk-7R2WLDOS.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-ENRGKNR5.js";
+import {
+  createSafeErrorMessage
+} from "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-XZE4XARH.js";
+import "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/commands/plan-sprint-list-fast.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+import { Command } from "commander";
+async function runPlanSprintListAction(options) {
+  try {
+    let sprints;
+    let scope;
+    if (options.archived) {
+      sprints = await listSprints(true);
+      scope = "archived";
+    } else if (options.current) {
+      sprints = await listSprints(false);
+      scope = "current";
+    } else {
+      const current = await listSprints(false);
+      const archived = await listSprints(true);
+      sprints = [...current, ...archived];
+      scope = "all";
+    }
+    if (options.json) {
+      process.stdout.write(
+        `${JSON.stringify(
+          {
+            scope,
+            total: sprints.length,
+            sprints: sprints.map((sprint) => ({
+              id: sprint.id,
+              name: sprint.name,
+              status: sprint.status,
+              startDate: sprint.startDate,
+              endDate: sprint.endDate,
+              taskCount: sprint.taskIds.length,
+              capacity: {
+                allocatedHours: sprint.capacity.allocatedHours,
+                totalHours: sprint.capacity.totalHours,
+                utilizationPercent: sprint.capacity.utilizationPercent
+              }
+            }))
+          },
+          null,
+          2
+        )}
+`
+      );
+      return;
+    }
+    if (sprints.length === 0) {
+      console.log(chalk.yellow("No sprints found"));
+      return;
+    }
+    console.log("");
+    console.log(chalk.bold("Sprints"));
+    console.log("");
+    const table = new Table({
+      head: [
+        chalk.cyan("ID"),
+        chalk.cyan("Name"),
+        chalk.cyan("Dates"),
+        chalk.cyan("Status"),
+        chalk.cyan("Tasks"),
+        chalk.cyan("Capacity")
+      ],
+      colWidths: [20, 25, 25, 12, 8, 15]
+    });
+    for (const sprint of sprints) {
+      const statusColor = sprint.status === "completed" ? chalk.green : sprint.status === "active" ? chalk.blue : chalk.yellow;
+      table.push([
+        sprint.id,
+        sprint.name,
+        `${sprint.startDate} to ${sprint.endDate}`,
+        statusColor(sprint.status),
+        sprint.taskIds.length.toString(),
+        `${sprint.capacity.utilizationPercent.toFixed(0)}%`
+      ]);
+    }
+    console.log(table.toString());
+    console.log("");
+    console.log(chalk.dim(`Total: ${sprints.length} sprints`));
+    console.log("");
+  } catch (error) {
+    if (error instanceof ExitCodeError) {
+      throw error;
+    }
+    const message = createSafeErrorMessage(error, "sprint list");
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify({ error: message })}
+`);
+      throw new ExitCodeError(1);
+    }
+    console.error(chalk.red(`Error listing sprints: ${message}`));
+    throw new ExitCodeError(1);
+  }
+}
+function createPlanSprintListFastCommand() {
+  const plan = new Command("plan").alias("pl").description("Work definition and organization");
+  const sprint = new Command("sprint").description("Manage sprints");
+  sprint.command("list").description("(beta) List sprints").option("--current", "(OPTIONAL) Only show current sprints").option("--archived", "(OPTIONAL) Only show archived sprints").option("--json", "(OPTIONAL) Output structured JSON instead of formatted text").action(runPlanSprintListAction);
+  plan.addCommand(sprint);
+  return plan;
+}
+export {
+  createPlanSprintListFastCommand,
+  runPlanSprintListAction
+};
+//# sourceMappingURL=plan-sprint-list-fast-LURAX47V.js.map