@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/packages/shared/extract-code-paths.ts

@@ -0,0 +1,66 @@
+import {
+	CODE_PATH_BARE_REGEX,
+	isCodeFilePath,
+	isCodeFilePathStrict,
+} from "./code-file";
+
+const FENCED_CODE_BLOCK = /(^|\n)([ \t]*)(```|~~~)[\s\S]*?\n\2\3/g;
+const HTML_COMMENT = /<!--[\s\S]*?-->/g;
+// Match InlineMarkdown.tsx's bare-URL regex exactly so URL ranges excised
+// here mirror the ranges the renderer would consume.
+const URL_REGEX = /https?:\/\/[^\s<>"']+/g;
+const BACKTICK_SPAN = /`([^`\n]+)`/g;
+
+/**
+ * Extract candidate code-file paths from markdown text. Mirrors the renderer's
+ * detection precedence so the validator only sees paths the renderer would
+ * actually linkify:
+ *   1. fenced code blocks and HTML comments are stripped first;
+ *   2. URL ranges are excised before the bare-prose scan (URLs win);
+ *   3. backtick spans matching `isCodeFilePath` are collected;
+ *   4. bare-prose paths matching `CODE_PATH_BARE_REGEX` and
+ *      `isCodeFilePathStrict` are collected.
+ *
+ * Hash anchors (`#L42`) are stripped from results to match the renderer's
+ * `cleanPath` transform. Returns deduped candidate strings.
+ */
+export function extractCandidateCodePaths(markdown: string): string[] {
+	const stripped = markdown
+		.replace(FENCED_CODE_BLOCK, "")
+		.replace(HTML_COMMENT, "");
+
+	const candidates = new Set<string>();
+
+	let m: RegExpExecArray | null;
+	const backtickRe = new RegExp(BACKTICK_SPAN.source, "g");
+	while ((m = backtickRe.exec(stripped)) !== null) {
+		const inner = m[1].trim();
+		if (isCodeFilePath(inner)) {
+			candidates.add(inner.replace(/#.*$/, ""));
+		}
+	}
+
+	for (const line of stripped.split("\n")) {
+		const urlRanges: Array<[number, number]> = [];
+		const urlRe = new RegExp(URL_REGEX.source, "g");
+		while ((m = urlRe.exec(line)) !== null) {
+			urlRanges.push([m.index, m.index + m[0].length]);
+		}
+
+		const pathRe = new RegExp(CODE_PATH_BARE_REGEX.source, "g");
+		while ((m = pathRe.exec(line)) !== null) {
+			const start = m.index;
+			const end = start + m[0].length;
+			const prev = start === 0 ? "" : line[start - 1];
+			if (/\w/.test(prev)) continue;
+			const overlapsUrl = urlRanges.some(
+				([s, e]) => start < e && end > s,
+			);
+			if (overlapsUrl) continue;
+			if (!isCodeFilePathStrict(m[0])) continue;
+			candidates.add(m[0].replace(/#.*$/, ""));
+		}
+	}
+
+	return Array.from(candidates);
+}

package/3p/pi-plannotator/packages/shared/favicon.ts

@@ -0,0 +1,5 @@
+export const FAVICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#070b14"/>
+  <rect x="12" y="28" width="40" height="14" rx="3" fill="#E0BA55" opacity="0.35"/>
+  <text x="32" y="46" text-anchor="middle" font-family="Inter,system-ui,sans-serif" font-weight="800" font-size="42" fill="white">P</text>
+</svg>`;

package/3p/pi-plannotator/packages/shared/feedback-templates.test.ts

@@ -0,0 +1,65 @@
+import { describe, test, expect } from "bun:test";
+import { planDenyFeedback } from "./feedback-templates";
+
+describe("feedback-templates", () => {
+  /**
+   * The whole point of this module: all three integrations (hook, opencode, pi)
+   * produce identical output except for the tool name. If this test fails,
+   * the templates have diverged — which is what we're trying to prevent.
+   */
+  test("plan deny is identical across integrations (modulo tool name)", () => {
+    const normalize = (s: string) =>
+      s.replace(/ExitPlanMode|submit_plan|exit_plan_mode|plannotator_submit_plan/g, "TOOL");
+
+    const feedback = "## 1. Remove auth section\n> Not needed anymore.";
+    const hook = normalize(planDenyFeedback(feedback, "ExitPlanMode"));
+    const opencode = normalize(planDenyFeedback(feedback, "submit_plan"));
+    const pi = normalize(planDenyFeedback(feedback, "plannotator_submit_plan"));
+
+    expect(hook).toBe(opencode);
+    expect(opencode).toBe(pi);
+  });
+
+  /**
+   * The deny template must embed the user's feedback verbatim — no truncation,
+   * no escaping, no wrapping. The agent needs the raw annotation output.
+   */
+  test("plan deny preserves feedback content verbatim", () => {
+    const feedback = "## 1. Change auth\n**From:**\n```\nold code\n```\n**To:**\n```\nnew code\n```";
+    const result = planDenyFeedback(feedback);
+    expect(result).toContain(feedback);
+  });
+
+  /**
+   * Empty feedback should not produce a broken message — the agent needs
+   * something actionable even if the user didn't write annotations.
+   */
+  test("plan deny handles empty feedback gracefully", () => {
+    const result = planDenyFeedback("");
+    expect(result.length).toBeGreaterThan(50);
+    expect(result).toBe(result.trimEnd());
+  });
+
+  /**
+   * Version history is keyed by the plan's first # heading + date.
+   * If the agent renames the heading on resubmission, the version chain breaks
+   * and the user loses diffs (#296). The deny template must instruct the agent
+   * to preserve the title.
+   */
+  test("plan deny instructs agent to preserve plan title", () => {
+    const result = planDenyFeedback("feedback");
+    expect(result.toLowerCase()).toContain("title");
+    expect(result.toLowerCase()).toContain("heading");
+  });
+
+  test("plan deny can include a plan file hint for file-based integrations", () => {
+    const result = planDenyFeedback("feedback", "plannotator_submit_plan", {
+      planFilePath: "plans/auth.md",
+    });
+
+    expect(result).toContain("plans/auth.md");
+    expect(result).toContain("edit this file");
+    expect(result).toContain("plannotator_submit_plan");
+  });
+
+});

package/3p/pi-plannotator/packages/shared/feedback-templates.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared feedback templates for all agent integrations.
+ *
+ * The plan deny template was tuned in #224 / commit 3dca977 to use strong
+ * directive framing — Claude was ignoring softer phrasing.
+ *
+ * IMPORTANT: This module is imported by packages/ui/utils/parser.ts which is
+ * bundled into the browser SPA. It must NOT import from ./prompts or ./config
+ * (which depend on node:fs, node:os, node:child_process). Keep it self-contained.
+ *
+ * Server-side call sites use getPlanDeniedPrompt() from ./prompts directly.
+ * This module is only kept for the browser's wrapFeedbackForAgent clipboard feature.
+ */
+
+export interface PlanDenyFeedbackOptions {
+  planFilePath?: string;
+}
+
+export const planDenyFeedback = (
+  feedback: string,
+  toolName: string = "ExitPlanMode",
+  options?: PlanDenyFeedbackOptions,
+): string => {
+  const planFileRule = options?.planFilePath
+    ? `- Your plan is saved at: ${options.planFilePath}\n  You can edit this file to make targeted changes, then pass its path to ${toolName}.\n`
+    : "";
+
+  return `YOUR PLAN WAS NOT APPROVED.\n\nYou MUST revise the plan to address ALL of the feedback below before calling ${toolName} again.\n\nRules:\n${planFileRule}- Do not resubmit the same plan unchanged.\n- Do NOT change the plan title (first # heading) unless the user explicitly asks you to.\n\n${feedback || "Plan changes requested"}`;
+};

package/3p/pi-plannotator/packages/shared/goal-setup.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createFactsResult,
+  createInterviewResult,
+  factsResultToMarkdown,
+  filterReviewableFacts,
+  normalizeFactsBundle,
+  normalizeGoalSetupBundle,
+  normalizeInterviewBundle,
+} from "./goal-setup";
+
+describe("goal setup model", () => {
+  test("normalizes bundled interview questions", () => {
+    const bundle = normalizeInterviewBundle({
+      title: "Goal setup",
+      questions: [
+        {
+          id: "scope",
+          prompt: "What is in scope?",
+          answerMode: "multi-custom",
+          options: [{ id: "ui", label: "UI" }],
+          recommendedAnswer: "Ship the interactive flow.",
+        },
+      ],
+    });
+
+    expect(bundle.stage).toBe("interview");
+    expect(bundle.questions[0]).toMatchObject({
+      id: "scope",
+      answerMode: "multi-custom",
+      recommendedAnswer: "Ship the interactive flow.",
+      required: true,
+    });
+    expect(bundle.questions[0].options?.[0].label).toBe("UI");
+  });
+
+  test("creates complete interview result from selected options and text", () => {
+    const bundle = normalizeGoalSetupBundle(
+      {
+        stage: "interview",
+        questions: [
+          { id: "audience", prompt: "Who uses this?", answerMode: "single" },
+          { id: "risk", prompt: "Main risk?" },
+        ],
+      },
+      "interview"
+    );
+
+    if (bundle.stage !== "interview") throw new Error("expected interview");
+
+    const result = createInterviewResult(bundle, [
+      {
+        questionId: "audience",
+        selectedOptionIds: ["agents"],
+        customAnswer: "",
+        answer: "Agents",
+        completed: false,
+      },
+      {
+        questionId: "risk",
+        selectedOptionIds: [],
+        customAnswer: "",
+        answer: "Slow one-at-a-time prompting",
+        completed: false,
+      },
+    ]);
+
+    expect(result.answers.map((answer) => answer.completed)).toEqual([
+      true,
+      true,
+    ]);
+  });
+
+  test("preserves skipped interview answers with notes", () => {
+    const bundle = normalizeGoalSetupBundle(
+      {
+        stage: "interview",
+        questions: [
+          { id: "scope", prompt: "What is out of scope?" },
+        ],
+      },
+      "interview"
+    );
+
+    if (bundle.stage !== "interview") throw new Error("expected interview");
+
+    const result = createInterviewResult(bundle, [
+      {
+        questionId: "scope",
+        selectedOptionIds: [],
+        customAnswer: "",
+        answer: "",
+        note: "I need more context before answering.",
+        completed: false,
+        skipped: true,
+      },
+    ]);
+
+    expect(result.answers[0]).toMatchObject({
+      questionId: "scope",
+      completed: false,
+      skipped: true,
+      note: "I need more context before answering.",
+    });
+  });
+
+  test("filters previously accepted facts unless the bundle opts in", () => {
+    const bundle = normalizeFactsBundle({
+      stage: "facts",
+      facts: [
+        { id: "old", text: "Already accepted.", accepted: true },
+        { id: "new", text: "Needs review." },
+      ],
+    });
+
+    expect(filterReviewableFacts(bundle).map((fact) => fact.id)).toEqual([
+      "new",
+    ]);
+  });
+
+  test("preserves recommended automated verification as preselected state", () => {
+    const bundle = normalizeFactsBundle({
+      stage: "facts",
+      facts: [
+        {
+          id: "build",
+          text: "The build must pass.",
+          recommendedAutomatedVerification: true,
+        },
+      ],
+    });
+
+    expect(bundle.facts[0].automatedVerification).toBe(true);
+    expect(bundle.facts[0].recommendedAutomatedVerification).toBe(true);
+  });
+
+  test("serializes accepted facts as flat markdown while metadata stays structured", () => {
+    const markdown = factsResultToMarkdown([
+      {
+        id: "fact-1",
+        text: "The skill batches all interview questions.",
+        accepted: true,
+        removed: false,
+        comment: "Important for speed.",
+        automatedVerification: true,
+        recommendedAutomatedVerification: true,
+      },
+      {
+        id: "fact-2",
+        text: "A removed fact is omitted.",
+        accepted: true,
+        removed: true,
+        automatedVerification: false,
+      },
+    ]);
+
+    expect(markdown).toContain(
+      "- The skill batches all interview questions."
+    );
+    expect(markdown).not.toContain("Automated verification");
+    expect(markdown).not.toContain("Comment:");
+    expect(markdown).not.toContain("A removed fact is omitted");
+  });
+
+  test("merges facts result against bundle order", () => {
+    const bundle = normalizeFactsBundle({
+      stage: "facts",
+      facts: [
+        { id: "a", text: "A" },
+        { id: "b", text: "B", recommendedAutomatedVerification: true },
+      ],
+    });
+
+    const result = createFactsResult(bundle, [
+      {
+        id: "b",
+        text: "B edited",
+        accepted: true,
+        removed: false,
+        automatedVerification: false,
+      },
+    ]);
+
+    expect(result.facts.map((fact) => fact.id)).toEqual(["a", "b"]);
+    expect(result.facts[1]).toMatchObject({
+      text: "B edited",
+      accepted: true,
+      automatedVerification: false,
+      recommendedAutomatedVerification: true,
+    });
+  });
+
+  test("allows submitted facts to clear existing comments", () => {
+    const bundle = normalizeFactsBundle({
+      stage: "facts",
+      facts: [{ id: "a", text: "A", comment: "Needs detail." }],
+    });
+
+    const result = createFactsResult(bundle, [
+      {
+        id: "a",
+        text: "A",
+        accepted: true,
+        removed: false,
+        comment: "",
+        automatedVerification: false,
+      },
+    ]);
+
+    expect(result.facts[0].comment).toBeUndefined();
+  });
+
+  test("rejects blank live fact text", () => {
+    const bundle = normalizeFactsBundle({
+      stage: "facts",
+      facts: [{ id: "a", text: "A" }],
+    });
+
+    expect(() =>
+      createFactsResult(bundle, [
+        {
+          id: "a",
+          text: "   ",
+          accepted: true,
+          removed: false,
+          automatedVerification: false,
+        },
+      ])
+    ).toThrow('Fact "a" text cannot be empty');
+  });
+});