@ilya-lesikov/pi-pi 0.1.0

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

@@ -0,0 +1,247 @@
+import { loadConfig, type PlannotatorConfig, type PromptRuntime } from "./config";
+
+// ─── Template engine ─────────────────────────────────────────────────────────
+
+export function resolveTemplate(
+  template: string,
+  vars: Record<string, string | undefined>,
+): string {
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const val = vars[key];
+    return val !== undefined ? val : match;
+  });
+}
+
+// ─── Tool name map ───────────────────────────────────────────────────────────
+
+export const PLAN_TOOL_NAMES: Record<PromptRuntime, string> = {
+  "claude-code": "ExitPlanMode",
+  amp: "ExitPlanMode",
+  droid: "ExitPlanMode",
+  "kiro-cli": "ExitPlanMode",
+  opencode: "submit_plan",
+  "copilot-cli": "exit_plan_mode",
+  pi: "plannotator_submit_plan",
+  codex: "ExitPlanMode",
+  "gemini-cli": "exit_plan_mode",
+};
+
+export function getPlanToolName(runtime?: PromptRuntime | null): string {
+  return (runtime && PLAN_TOOL_NAMES[runtime]) || "ExitPlanMode";
+}
+
+export function buildPlanFileRule(toolName: string, planFilePath?: string): string {
+  if (!planFilePath) return "";
+  return `- Your plan is saved at: ${planFilePath}\n  You can edit this file to make targeted changes, then pass its path to ${toolName}.\n`;
+}
+
+// ─── Default constants ───────────────────────────────────────────────────────
+
+export const DEFAULT_REVIEW_APPROVED_PROMPT = "# Code Review\n\nCode review completed — no changes requested.";
+
+export const DEFAULT_REVIEW_DENIED_SUFFIX = "\nThe reviewer has identified issues above. You must address all of them.";
+
+export const DEFAULT_PLAN_DENIED_PROMPT =
+  "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}}";
+
+export const DEFAULT_PLAN_APPROVED_PROMPT =
+  "Plan approved. You now have full tool access (read, bash, edit, write). Execute the plan in {{planFilePath}}. {{doneMsg}}";
+
+export const DEFAULT_PLAN_APPROVED_WITH_NOTES_PROMPT =
+  "Plan approved with notes! You now have full tool access (read, bash, edit, write). Execute the plan in {{planFilePath}}. {{doneMsg}}\n\n## Implementation Notes\n\nThe user approved your plan but added the following notes to consider during implementation:\n\n{{feedback}}\n\nProceed with implementation, incorporating these notes where applicable.";
+
+export const DEFAULT_PLAN_AUTO_APPROVED_PROMPT =
+  "Plan auto-approved (non-interactive mode). Execute the plan now.";
+
+export const DEFAULT_ANNOTATE_FILE_FEEDBACK_PROMPT =
+  "# Markdown Annotations\n\n{{fileHeader}}: {{filePath}}\n\n{{feedback}}\n\nPlease address the annotation feedback above.";
+
+export const DEFAULT_ANNOTATE_MESSAGE_FEEDBACK_PROMPT =
+  "# Message Annotations\n\n{{feedback}}\n\nPlease address the annotation feedback above.";
+
+export const DEFAULT_ANNOTATE_APPROVED_PROMPT = "The user approved.";
+
+// ─── Core resolver ───────────────────────────────────────────────────────────
+
+type PromptSection = "review" | "plan" | "annotate";
+type PromptKey = "approved" | "approvedWithNotes" | "autoApproved" | "denied"
+  | "fileFeedback" | "messageFeedback";
+
+interface PromptLookupOptions {
+  section: PromptSection;
+  key: PromptKey;
+  runtime?: PromptRuntime | null;
+  config?: PlannotatorConfig;
+  fallback: string;
+  runtimeFallbacks?: Partial<Record<PromptRuntime, string>>;
+}
+
+function normalizePrompt(prompt: unknown): string | undefined {
+  if (typeof prompt !== "string") return undefined;
+  return prompt.trim() ? prompt : undefined;
+}
+
+export function getConfiguredPrompt(options: PromptLookupOptions): string {
+  const resolvedConfig = options.config ?? loadConfig();
+  const section = resolvedConfig.prompts?.[options.section];
+  const runtimePrompt = options.runtime
+    ? normalizePrompt(section?.runtimes?.[options.runtime]?.[options.key])
+    : undefined;
+  const genericPrompt = normalizePrompt(section?.[options.key]);
+  const runtimeFallback = options.runtime
+    ? options.runtimeFallbacks?.[options.runtime]
+    : undefined;
+
+  return runtimePrompt ?? genericPrompt ?? runtimeFallback ?? options.fallback;
+}
+
+type FeedbackVars = Record<string, string | undefined>;
+
+// ─── Review wrappers ─────────────────────────────────────────────────────────
+
+export function getReviewApprovedPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+): string {
+  return getConfiguredPrompt({
+    section: "review",
+    key: "approved",
+    runtime,
+    config,
+    fallback: DEFAULT_REVIEW_APPROVED_PROMPT,
+  });
+}
+
+const REVIEW_DENIED_RUNTIME_DEFAULTS: Partial<Record<PromptRuntime, string>> = {
+  opencode: "\n\nPlease address this feedback.",
+  pi: "\n\nPlease address this feedback.",
+};
+
+export function getReviewDeniedSuffix(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+): string {
+  return getConfiguredPrompt({
+    section: "review",
+    key: "denied",
+    runtime,
+    config,
+    fallback: DEFAULT_REVIEW_DENIED_SUFFIX,
+    runtimeFallbacks: REVIEW_DENIED_RUNTIME_DEFAULTS,
+  });
+}
+
+// ─── Plan wrappers ───────────────────────────────────────────────────────────
+
+export function getPlanDeniedPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+  vars?: FeedbackVars,
+): string {
+  const template = getConfiguredPrompt({
+    section: "plan",
+    key: "denied",
+    runtime,
+    config,
+    fallback: DEFAULT_PLAN_DENIED_PROMPT,
+  });
+  return resolveTemplate(template, vars ?? {});
+}
+
+const PLAN_APPROVED_RUNTIME_DEFAULTS: Partial<Record<PromptRuntime, string>> = {
+  opencode: "Plan approved!{{doneMsg}}",
+};
+
+export function getPlanApprovedPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+  vars?: FeedbackVars,
+): string {
+  const template = getConfiguredPrompt({
+    section: "plan",
+    key: "approved",
+    runtime,
+    config,
+    fallback: DEFAULT_PLAN_APPROVED_PROMPT,
+    runtimeFallbacks: PLAN_APPROVED_RUNTIME_DEFAULTS,
+  });
+  return resolveTemplate(template, vars ?? {});
+}
+
+const PLAN_APPROVED_WITH_NOTES_RUNTIME_DEFAULTS: Partial<Record<PromptRuntime, string>> = {
+  opencode: "Plan approved with notes!\n{{doneMsg}}\n\n## Implementation Notes\n\nThe user approved your plan but added the following notes to consider during implementation:\n\n{{feedback}}{{proceedSuffix}}",
+};
+
+export function getPlanApprovedWithNotesPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+  vars?: FeedbackVars,
+): string {
+  const template = getConfiguredPrompt({
+    section: "plan",
+    key: "approvedWithNotes",
+    runtime,
+    config,
+    fallback: DEFAULT_PLAN_APPROVED_WITH_NOTES_PROMPT,
+    runtimeFallbacks: PLAN_APPROVED_WITH_NOTES_RUNTIME_DEFAULTS,
+  });
+  return resolveTemplate(template, { proceedSuffix: "", ...vars });
+}
+
+export function getPlanAutoApprovedPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+): string {
+  return getConfiguredPrompt({
+    section: "plan",
+    key: "autoApproved",
+    runtime,
+    config,
+    fallback: DEFAULT_PLAN_AUTO_APPROVED_PROMPT,
+  });
+}
+
+// ─── Annotate wrappers ──────────────────────────────────────────────────────
+
+export function getAnnotateFileFeedbackPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+  vars?: FeedbackVars,
+): string {
+  const template = getConfiguredPrompt({
+    section: "annotate",
+    key: "fileFeedback",
+    runtime,
+    config,
+    fallback: DEFAULT_ANNOTATE_FILE_FEEDBACK_PROMPT,
+  });
+  return resolveTemplate(template, vars ?? {});
+}
+
+export function getAnnotateMessageFeedbackPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+  vars?: FeedbackVars,
+): string {
+  const template = getConfiguredPrompt({
+    section: "annotate",
+    key: "messageFeedback",
+    runtime,
+    config,
+    fallback: DEFAULT_ANNOTATE_MESSAGE_FEEDBACK_PROMPT,
+  });
+  return resolveTemplate(template, vars ?? {});
+}
+
+export function getAnnotateApprovedPrompt(
+  runtime?: PromptRuntime | null,
+  config?: PlannotatorConfig,
+): string {
+  return getConfiguredPrompt({
+    section: "annotate",
+    key: "approved",
+    runtime,
+    config,
+    fallback: DEFAULT_ANNOTATE_APPROVED_PROMPT,
+  });
+}

package/3p/pi-plannotator/packages/shared/reference-common.ts

@@ -0,0 +1,87 @@
+// --- Vault file tree helpers ---
+
+export const FILE_BROWSER_EXCLUDED = [
+	"node_modules/",
+	".git/",
+	"dist/",
+	"build/",
+	".next/",
+	"__pycache__/",
+	".obsidian/",
+	".trash/",
+	".venv/",
+	"vendor/",
+	"target/",
+	".cache/",
+	"coverage/",
+	".turbo/",
+	".svelte-kit/",
+	".nuxt/",
+	".output/",
+	".parcel-cache/",
+	".webpack/",
+	".expo/",
+	"_site/",
+	"public/",
+	".jekyll-cache/",
+	"out/",
+	".docusaurus/",
+	"storybook-static/",
+];
+
+export interface VaultNode {
+	name: string;
+	path: string; // relative path within vault
+	type: "file" | "folder";
+	children?: VaultNode[];
+}
+
+/**
+ * Build a nested file tree from a sorted list of relative paths.
+ * Folders are sorted before files at each level.
+ */
+export function buildFileTree(relativePaths: string[]): VaultNode[] {
+	const root: VaultNode[] = [];
+
+	for (const filePath of relativePaths) {
+		const parts = filePath.split("/");
+		let current = root;
+		let pathSoFar = "";
+
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			pathSoFar = pathSoFar ? `${pathSoFar}/${part}` : part;
+			const isFile = i === parts.length - 1;
+
+			let node = current.find(
+				(n) => n.name === part && n.type === (isFile ? "file" : "folder"),
+			);
+			if (!node) {
+				node = {
+					name: part,
+					path: pathSoFar,
+					type: isFile ? "file" : "folder",
+				};
+				if (!isFile) node.children = [];
+				current.push(node);
+			}
+			if (!isFile) {
+				current = node.children!;
+			}
+		}
+	}
+
+	// Sort: folders first (alphabetical), then files (alphabetical)
+	const sortNodes = (nodes: VaultNode[]) => {
+		nodes.sort((a, b) => {
+			if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
+			return a.name.localeCompare(b.name);
+		});
+		for (const node of nodes) {
+			if (node.children) sortNodes(node.children);
+		}
+	};
+	sortNodes(root);
+
+	return root;
+}

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

@@ -0,0 +1,71 @@
+export interface RepoInfo {
+	/** Display string (e.g., "backnotprop/plannotator" or "my-project") */
+	display: string;
+	/** Current git branch (if in a git repo) */
+	branch?: string;
+	/** Host of the git remote (e.g., "github.com", "gitlab.com"). Populated */
+	/** only when the remote URL is parseable; absent for directory-only fallbacks. */
+	host?: string;
+}
+
+/**
+ * Parse org/repo from a git remote URL
+ *
+ * Handles:
+ * - SSH: git@github.com:org/repo.git
+ * - HTTPS: https://github.com/org/repo.git
+ * - SSH with port: ssh://git@github.com:22/org/repo.git
+ * - GitLab subgroups: git@gitlab.com:group/subgroup/project.git
+ */
+export function parseRemoteUrl(url: string): string | null {
+	if (!url) return null;
+
+	// SSH with port: ssh://git@host:22/path.git — strip scheme+host+port
+	const sshPortMatch = url.match(/^ssh:\/\/[^/]+(?::\d+)?\/(.+?)(?:\.git)?$/);
+	if (sshPortMatch) return sshPortMatch[1];
+
+	// SSH format: git@host:path.git — capture full path after ':'
+	// Reject URLs with :// scheme (HTTPS with non-standard ports like :8443)
+	if (!url.includes("://")) {
+		const sshMatch = url.match(/:([^/][^:]*?)(?:\.git)?$/);
+		if (sshMatch) return sshMatch[1];
+	}
+
+	// HTTPS format: https://host/path.git — capture full path after host
+	const httpsMatch = url.match(/^https?:\/\/[^/]+\/(.+?)(?:\.git)?$/);
+	if (httpsMatch) return httpsMatch[1];
+
+	return null;
+}
+
+/**
+ * Parse the host from a git remote URL. Returns null when the shape
+ * doesn't match a known remote form. Used to identify the forge
+ * (github.com, gitlab.com, self-hosted) so inline mention / issue
+ * refs can link to the correct destination instead of assuming GitHub.
+ */
+export function parseRemoteHost(url: string): string | null {
+	if (!url) return null;
+	// ssh://git@host:port/path
+	const sshPort = url.match(/^ssh:\/\/(?:[^@]+@)?([^:/]+)/i);
+	if (sshPort) return sshPort[1];
+	// git@host:path
+	if (!url.includes('://')) {
+		const ssh = url.match(/^[^@\s]+@([^:\s]+):/);
+		if (ssh) return ssh[1];
+	}
+	// https://host/path or http://host/path
+	const https = url.match(/^https?:\/\/([^/:]+)/i);
+	if (https) return https[1];
+	return null;
+}
+
+/**
+ * Get directory name from path
+ */
+export function getDirName(path: string): string | null {
+	if (!path) return null;
+	const trimmed = path.trim().replace(/\/+$/, "");
+	const parts = trimmed.split("/");
+	return parts[parts.length - 1] || null;
+}

package/3p/pi-plannotator/packages/shared/resolve-file.test.ts

@@ -0,0 +1,113 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { resolveCodeFile } from "./resolve-file";
+
+let root: string;
+
+beforeAll(() => {
+	root = mkdtempSync(join(tmpdir(), "plannotator-resolve-"));
+	mkdirSync(join(root, "packages/editor"), { recursive: true });
+	mkdirSync(join(root, "packages/review-editor"), { recursive: true });
+	mkdirSync(join(root, "packages/ui/components"), { recursive: true });
+	mkdirSync(join(root, "node_modules/junk"), { recursive: true });
+	writeFileSync(join(root, "packages/editor/App.tsx"), "// editor");
+	writeFileSync(join(root, "packages/review-editor/App.tsx"), "// review");
+	writeFileSync(join(root, "packages/ui/components/Button.tsx"), "// btn");
+	writeFileSync(join(root, "packages/ui/index.ts"), "// idx");
+	writeFileSync(join(root, "node_modules/junk/App.tsx"), "// junk");
+});
+
+afterAll(() => {
+	rmSync(root, { recursive: true, force: true });
+});
+
+describe("resolveCodeFile", () => {
+	test("resolves an exact relative path", async () => {
+		const r = await resolveCodeFile("packages/editor/App.tsx", root);
+		expect(r.kind).toBe("found");
+		if (r.kind === "found") {
+			expect(r.path).toBe(join(root, "packages/editor/App.tsx"));
+		}
+	});
+
+	test("resolves an abbreviated path via suffix match", async () => {
+		const r = await resolveCodeFile("editor/App.tsx", root);
+		expect(r.kind).toBe("found");
+		if (r.kind === "found") {
+			expect(r.path).toBe(join(root, "packages/editor/App.tsx"));
+		}
+	});
+
+	test("returns ambiguous when basename matches multiple files", async () => {
+		const r = await resolveCodeFile("App.tsx", root);
+		expect(r.kind).toBe("ambiguous");
+		if (r.kind === "ambiguous") {
+			expect(r.matches).toHaveLength(2);
+		}
+	});
+
+	test("returns not_found for a non-existent path", async () => {
+		const r = await resolveCodeFile("packages/ui/shortcuts/core.ts", root);
+		expect(r.kind).toBe("not_found");
+	});
+
+	test("ignores node_modules", async () => {
+		const r = await resolveCodeFile("junk/App.tsx", root);
+		expect(r.kind).toBe("not_found");
+	});
+
+	test("does not match similarly-named directories", async () => {
+		// myeditor/App.tsx must NOT match packages/editor/App.tsx — segment boundary required.
+		const r = await resolveCodeFile("myeditor/App.tsx", root);
+		expect(r.kind).toBe("not_found");
+	});
+
+	test("returns found for a single-segment input that uniquely exists", async () => {
+		// `index.ts` is bare basename; only one in tree.
+		const r = await resolveCodeFile("index.ts", root);
+		expect(r.kind).toBe("found");
+		if (r.kind === "found") {
+			expect(r.path).toBe(join(root, "packages/ui/index.ts"));
+		}
+	});
+
+	test("strips leading ./ before suffix matching", async () => {
+		// Earlier this fell through to step 3 with target='./editor/app.tsx'
+		// and never matched any real file. The cleanup makes it work.
+		const r = await resolveCodeFile("./editor/App.tsx", root);
+		expect(r.kind).toBe("found");
+		if (r.kind === "found") {
+			expect(r.path).toBe(join(root, "packages/editor/App.tsx"));
+		}
+	});
+
+	test("does NOT strip leading ../ — without baseDir, refuses to fabricate", async () => {
+		// `../foo.tsx` is meaningful (escape parent). With no baseDir context,
+		// we can't honor it, so we must fail rather than silently returning
+		// an unrelated file with the same basename from inside cwd.
+		const r = await resolveCodeFile("../editor/App.tsx", root);
+		expect(r.kind).toBe("not_found");
+	});
+
+	test("resolves via baseDir when input is relative to active doc", async () => {
+		// Linked doc at `<root>/packages/review-editor/...` references `../editor/App.tsx`
+		const baseDir = join(root, "packages/review-editor");
+		const r = await resolveCodeFile("../editor/App.tsx", root, baseDir);
+		expect(r.kind).toBe("found");
+		if (r.kind === "found") {
+			expect(r.path).toBe(join(root, "packages/editor/App.tsx"));
+		}
+	});
+
+	test("baseDir miss falls through to suffix walk", async () => {
+		// baseDir doesn't have the file, but cwd tree does — walk catches it.
+		const baseDir = join(root, "packages/review-editor");
+		const r = await resolveCodeFile("ui/components/Button.tsx", root, baseDir);
+		expect(r.kind).toBe("found");
+		if (r.kind === "found") {
+			expect(r.path).toBe(join(root, "packages/ui/components/Button.tsx"));
+		}
+	});
+});