@jwilger/pi-development-system 0.60.0 → 0.61.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.60.0",
+  "version": "0.61.0",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

package/src/planning/task-record.ts

@@ -38,15 +38,35 @@ const PLACEHOLDER =
 
 const isSection = (name: string): name is Section => SECTIONS.some((s) => s === name);
 
-const FENCE = /^\s*(?:```|~~~)/;
+const FENCE_LINE = /^\s*(`{3,}|~{3,})(.*)$/;
 const HEADING = /^#{1,6}\s/;
 
-/** For each line, whether it sits inside (or on the edge of) a fenced code block. */
+/** Opening fence: its character and length. Backtick fences cannot carry backticks in the info string. */
+const opening = (line: string): { char: string; length: number } | undefined => {
+  const m = FENCE_LINE.exec(line);
+  const run = m?.[1];
+  if (run === undefined || (run.startsWith("`") && (m?.[2] ?? "").includes("`"))) return undefined;
+  return { char: run.slice(0, 1), length: run.length };
+};
+
+/** A closing fence repeats the opening character at least as many times and carries no text. */
+const closes = (line: string, open: { char: string; length: number }): boolean => {
+  const m = FENCE_LINE.exec(line);
+  const run = m?.[1];
+  return (
+    run?.startsWith(open.char) === true && run.length >= open.length && (m?.[2] ?? "").trim() === ""
+  );
+};
+
+/** For each line, whether it sits inside (or on the edge of) a fenced code block, as CommonMark reads fences. */
 const fencedFlags = (lines: readonly string[]): boolean[] => {
-  let open = false;
+  let open: { char: string; length: number } | undefined;
   return lines.map((line) => {
-    if (!FENCE.test(line)) return open;
-    open = !open;
+    if (open === undefined) {
+      open = opening(line);
+      return open !== undefined;
+    }
+    if (closes(line, open)) open = undefined;
     return true;
   });
 };
@@ -95,9 +115,10 @@ function recordsIn(lines: readonly string[]): Located[] {
 /** A command or result without its backticks, or the body of a fenced block (its info string dropped). */
 const stripTicks = (text: string): string => {
   const lines = text.split("\n");
-  if (FENCE.test(lines[0] ?? "")) {
+  const fence = opening(lines[0] ?? "");
+  if (fence !== undefined) {
     const body = lines.slice(1);
-    if (FENCE.test(body.at(-1) ?? "")) body.pop();
+    if (closes(body.at(-1) ?? "", fence)) body.pop();
     return body.join("\n").trim();
   }
   return text.replace(/^`+|`+$/g, "").trim();
@@ -157,10 +178,13 @@ function locate(markdown: string, id: string | undefined): Located | ParseError
   const records = recordsIn(markdown.split("\n"));
   const names = records.map((r) => r.id).join(", ");
   if (id !== undefined) {
-    return (
-      records.find((r) => r.id === id) ??
-      parseError(`no task record "${id}" (found: ${names || "none"})`)
-    );
+    const named = records.filter((r) => r.id === id);
+    const [first] = named;
+    if (first === undefined)
+      return parseError(`no task record "${id}" (found: ${names || "none"})`);
+    return named.length === 1
+      ? first
+      : parseError(`task record "${id}" appears ${named.length} times; ids must be unique`);
   }
   const [only, ...rest] = records;
   if (only === undefined) return parseError(NO_HEADER);

package/src/tracker/github.ts

@@ -4,7 +4,7 @@ import { unwritable } from "./item-format.ts";
 
 /** Our status marker is a label; a user label with that name would change the status as a side effect. */
 const unusable = (item: { title: string; labels: readonly string[] }): string | undefined =>
-  item.labels.includes("in-progress")
+  item.labels.some(isMarker)
     ? '"in-progress" is reserved for the in-progress status; set status instead'
     : unwritable(item);
 
@@ -21,6 +21,8 @@ import {
 
 const FIELDS = "number,title,body,state,labels,comments";
 const IN_PROGRESS = "in-progress";
+/** GitHub label names are case-insensitive, so `In-Progress` is our marker too. */
+const isMarker = (name: string): boolean => name.toLowerCase() === IN_PROGRESS;
 const ISSUE_NUMBER = /^[1-9][0-9]*$/;
 const STATE_ARG = { open: "open", "in-progress": "open", done: "closed" } as const;
 
@@ -45,7 +47,7 @@ const isIssue = (value: unknown): value is GhIssue =>
 
 const statusOf = (state: string, labels: readonly string[]): WorkStatus => {
   if (state === "CLOSED") return "done";
-  return labels.includes(IN_PROGRESS) ? "in-progress" : "open";
+  return labels.some(isMarker) ? "in-progress" : "open";
 };
 
 const toItem = (issue: GhIssue): WorkItem => {
@@ -55,7 +57,7 @@ const toItem = (issue: GhIssue): WorkItem => {
     title: issue.title,
     body: issue.body ?? "",
     status: statusOf(issue.state, names),
-    labels: names.filter((n) => n !== IN_PROGRESS),
+    labels: names.filter((n) => !isMarker(n)),
     comments: (issue.comments ?? []).map((c) => c.body),
   };
 };
@@ -115,7 +117,7 @@ const view = async (gh: Gh, id: string): Promise<TrackerResult<WorkItem>> => {
   return raw.ok ? ok(toItem(raw.value)) : raw;
 };
 
-const LIST_LIMIT = 500;
+const LIST_LIMIT = 1000;
 
 /** The `gh issue list` arguments that select exactly the wanted status where gh can, so the limit bites last. */
 const listArgs = (status: WorkStatus | undefined): string[] => {
@@ -139,9 +141,14 @@ const listIssues = async (gh: Gh, filter: ItemFilter): Promise<TrackerResult<Wor
   if (!out.ok) return out;
   const parsed = parseIssues(out.value);
   if (parsed === undefined) return trackerError("gh issue list: unexpected output");
-  if (parsed.length >= LIST_LIMIT) {
+  // gh lists newest first. Cutting off old closed issues is harmless; cutting off open work is not.
+  if (parsed.length >= LIST_LIMIT && filter.status !== "done") {
+    const advice =
+      filter.status === undefined
+        ? "; ask for one status to narrow it"
+        : "; this adapter lists at most that many";
     return trackerError(
-      `gh issue list returned ${LIST_LIMIT} issues, so the list may be cut short; ask for one status (open, in-progress or done) to narrow it`,
+      `gh issue list returned ${LIST_LIMIT} issues, so the list may be cut short${advice}`,
     );
   }
   const items = parsed.map(toItem);
@@ -215,7 +222,7 @@ const updateIssue = async (
   const raw = await viewRaw(gh, id);
   if (!raw.ok) return raw;
   const current = toItem(raw.value);
-  const hadMarker = (raw.value.labels ?? []).some((l) => l.name === IN_PROGRESS);
+  const hadMarker = (raw.value.labels ?? []).some((l) => isMarker(l.name));
   if (patch.status === "in-progress") {
     // No --force: that would recolour the team's existing label. "Already exists" is success.
     const made = await gh(["label", "create", IN_PROGRESS]);

package/src/tracker/item-format.ts

@@ -7,6 +7,9 @@ import {
   type WorkStatus,
 } from "./types.ts";
 
+/** Every line terminator `.` in the item header pattern cannot cross, plus NEL for safety. */
+const LINE_BREAK = /[\r\n\u2028\u2029\u0085]/;
+
 const COMMENTS = "\n## Comments\n";
 
 /** Comment lines are quoted so nothing a comment says can look like one of our headings. */
@@ -24,9 +27,9 @@ const unquote = (text: string): string =>
 
 /** What the file format cannot hold, or undefined when the item can be written and read back. */
 export const unwritable = (item: Pick<WorkItem, "title" | "labels">): string | undefined => {
-  if (/[\r\n]/.test(item.title)) return "a work item title must be a single line";
+  if (LINE_BREAK.test(item.title)) return "a work item title must be a single line";
   if (item.title.trim() === "") return "a work item title cannot be blank";
-  const bad = item.labels.find((l) => /[\r\n,]/.test(l) || l.trim() === "");
+  const bad = item.labels.find((l) => LINE_BREAK.test(l) || l.includes(",") || l.trim() === "");
   return bad === undefined
     ? undefined
     : `label ${JSON.stringify(bad)} is blank or holds a comma or line break`;

package/src/tracker/work-item-tool.ts

@@ -24,7 +24,8 @@ const Parameters = Type.Object({
   ),
   status: Type.Optional(
     Type.Union([Type.Literal("open"), Type.Literal("in-progress"), Type.Literal("done")], {
-      description: "Status (update), or a filter (list).",
+      description:
+        "Status (update), or a filter (list). On GitHub, listing done shows the newest 1000 closed issues.",
     }),
   ),
   labels: Type.Optional(Type.Array(Type.String(), { description: "Labels (create, update)." })),