@plannotator/pi-extension 0.8.3

package/server.ts

@@ -0,0 +1,301 @@
+/**
+ * Node-compatible servers for Plannotator Pi extension.
+ *
+ * Pi loads extensions via jiti (Node.js), so we can't use Bun.serve().
+ * These are lightweight node:http servers implementing just the routes
+ * each UI needs — plan review, code review, and markdown annotation.
+ */
+
+import { createServer, type IncomingMessage, type Server } from "node:http";
+import { execSync } from "node:child_process";
+import os from "node:os";
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+function parseBody(req: IncomingMessage): Promise<Record<string, unknown>> {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk: string) => (data += chunk));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch {
+        resolve({});
+      }
+    });
+  });
+}
+
+function json(res: import("node:http").ServerResponse, data: unknown, status = 200): void {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+function html(res: import("node:http").ServerResponse, content: string): void {
+  res.writeHead(200, { "Content-Type": "text/html" });
+  res.end(content);
+}
+
+function listenOnRandomPort(server: Server): number {
+  server.listen(0);
+  const addr = server.address() as { port: number };
+  return addr.port;
+}
+
+/**
+ * Open URL in system browser (Node-compatible, no Bun $ dependency).
+ * Honors PLANNOTATOR_BROWSER and BROWSER env vars, matching packages/server/browser.ts.
+ */
+export function openBrowser(url: string): void {
+  try {
+    const browser = process.env.PLANNOTATOR_BROWSER || process.env.BROWSER;
+    const platform = process.platform;
+    const wsl = platform === "linux" && os.release().toLowerCase().includes("microsoft");
+
+    if (browser) {
+      if (process.env.PLANNOTATOR_BROWSER && platform === "darwin") {
+        execSync(`open -a ${JSON.stringify(browser)} ${JSON.stringify(url)}`, { stdio: "ignore" });
+      } else if (platform === "win32" || wsl) {
+        execSync(`cmd.exe /c start "" ${JSON.stringify(browser)} ${JSON.stringify(url)}`, { stdio: "ignore" });
+      } else {
+        execSync(`${JSON.stringify(browser)} ${JSON.stringify(url)}`, { stdio: "ignore" });
+      }
+    } else if (platform === "win32" || wsl) {
+      execSync(`cmd.exe /c start "" ${JSON.stringify(url)}`, { stdio: "ignore" });
+    } else if (platform === "darwin") {
+      execSync(`open ${JSON.stringify(url)}`, { stdio: "ignore" });
+    } else {
+      execSync(`xdg-open ${JSON.stringify(url)}`, { stdio: "ignore" });
+    }
+  } catch {
+    // Silently fail
+  }
+}
+
+// ── Plan Review Server ──────────────────────────────────────────────────
+
+export interface PlanServerResult {
+  port: number;
+  url: string;
+  waitForDecision: () => Promise<{ approved: boolean; feedback?: string }>;
+  stop: () => void;
+}
+
+export function startPlanReviewServer(options: {
+  plan: string;
+  htmlContent: string;
+  origin?: string;
+}): PlanServerResult {
+  let resolveDecision!: (result: { approved: boolean; feedback?: string }) => void;
+  const decisionPromise = new Promise<{ approved: boolean; feedback?: string }>((r) => {
+    resolveDecision = r;
+  });
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url!, `http://localhost`);
+
+    if (url.pathname === "/api/plan") {
+      json(res, { plan: options.plan, origin: options.origin ?? "pi" });
+    } else if (url.pathname === "/api/approve" && req.method === "POST") {
+      const body = await parseBody(req);
+      resolveDecision({ approved: true, feedback: body.feedback as string | undefined });
+      json(res, { ok: true });
+    } else if (url.pathname === "/api/deny" && req.method === "POST") {
+      const body = await parseBody(req);
+      resolveDecision({ approved: false, feedback: (body.feedback as string) || "Plan rejected" });
+      json(res, { ok: true });
+    } else {
+      html(res, options.htmlContent);
+    }
+  });
+
+  const port = listenOnRandomPort(server);
+
+  return {
+    port,
+    url: `http://localhost:${port}`,
+    waitForDecision: () => decisionPromise,
+    stop: () => server.close(),
+  };
+}
+
+// ── Code Review Server ──────────────────────────────────────────────────
+
+export type DiffType = "uncommitted" | "staged" | "unstaged" | "last-commit" | "branch";
+
+export interface DiffOption {
+  id: DiffType | "separator";
+  label: string;
+}
+
+export interface GitContext {
+  currentBranch: string;
+  defaultBranch: string;
+  diffOptions: DiffOption[];
+}
+
+export interface ReviewServerResult {
+  port: number;
+  url: string;
+  waitForDecision: () => Promise<{ feedback: string }>;
+  stop: () => void;
+}
+
+/** Run a git command and return stdout (empty string on error). */
+function git(cmd: string): string {
+  try {
+    return execSync(`git ${cmd}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return "";
+  }
+}
+
+export function getGitContext(): GitContext {
+  const currentBranch = git("rev-parse --abbrev-ref HEAD") || "HEAD";
+
+  let defaultBranch = "";
+  const symRef = git("symbolic-ref refs/remotes/origin/HEAD");
+  if (symRef) {
+    defaultBranch = symRef.replace("refs/remotes/origin/", "");
+  }
+  if (!defaultBranch) {
+    const hasMain = git("show-ref --verify refs/heads/main");
+    defaultBranch = hasMain ? "main" : "master";
+  }
+
+  const diffOptions: DiffOption[] = [
+    { id: "uncommitted", label: "Uncommitted changes" },
+    { id: "last-commit", label: "Last commit" },
+  ];
+  if (currentBranch !== defaultBranch) {
+    diffOptions.push({ id: "branch", label: `vs ${defaultBranch}` });
+  }
+
+  return { currentBranch, defaultBranch, diffOptions };
+}
+
+export function runGitDiff(diffType: DiffType, defaultBranch = "main"): { patch: string; label: string } {
+  switch (diffType) {
+    case "uncommitted":
+      return { patch: git("diff HEAD"), label: "Uncommitted changes" };
+    case "staged":
+      return { patch: git("diff --staged"), label: "Staged changes" };
+    case "unstaged":
+      return { patch: git("diff"), label: "Unstaged changes" };
+    case "last-commit":
+      return { patch: git("diff HEAD~1..HEAD"), label: "Last commit" };
+    case "branch":
+      return { patch: git(`diff ${defaultBranch}..HEAD`), label: `Changes vs ${defaultBranch}` };
+    default:
+      return { patch: "", label: "Unknown diff type" };
+  }
+}
+
+export function startReviewServer(options: {
+  rawPatch: string;
+  gitRef: string;
+  htmlContent: string;
+  origin?: string;
+  diffType?: DiffType;
+  gitContext?: GitContext;
+}): ReviewServerResult {
+  let currentPatch = options.rawPatch;
+  let currentGitRef = options.gitRef;
+  let currentDiffType: DiffType = options.diffType || "uncommitted";
+
+  let resolveDecision!: (result: { feedback: string }) => void;
+  const decisionPromise = new Promise<{ feedback: string }>((r) => {
+    resolveDecision = r;
+  });
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url!, `http://localhost`);
+
+    if (url.pathname === "/api/diff" && req.method === "GET") {
+      json(res, {
+        rawPatch: currentPatch,
+        gitRef: currentGitRef,
+        origin: options.origin ?? "pi",
+        diffType: currentDiffType,
+        gitContext: options.gitContext,
+      });
+    } else if (url.pathname === "/api/diff/switch" && req.method === "POST") {
+      const body = await parseBody(req);
+      const newType = body.diffType as DiffType;
+      if (!newType) {
+        json(res, { error: "Missing diffType" }, 400);
+        return;
+      }
+      const defaultBranch = options.gitContext?.defaultBranch || "main";
+      const result = runGitDiff(newType, defaultBranch);
+      currentPatch = result.patch;
+      currentGitRef = result.label;
+      currentDiffType = newType;
+      json(res, { rawPatch: currentPatch, gitRef: currentGitRef, diffType: currentDiffType });
+    } else if (url.pathname === "/api/feedback" && req.method === "POST") {
+      const body = await parseBody(req);
+      resolveDecision({ feedback: (body.feedback as string) || "" });
+      json(res, { ok: true });
+    } else {
+      html(res, options.htmlContent);
+    }
+  });
+
+  const port = listenOnRandomPort(server);
+
+  return {
+    port,
+    url: `http://localhost:${port}`,
+    waitForDecision: () => decisionPromise,
+    stop: () => server.close(),
+  };
+}
+
+// ── Annotate Server ─────────────────────────────────────────────────────
+
+export interface AnnotateServerResult {
+  port: number;
+  url: string;
+  waitForDecision: () => Promise<{ feedback: string }>;
+  stop: () => void;
+}
+
+export function startAnnotateServer(options: {
+  markdown: string;
+  filePath: string;
+  htmlContent: string;
+  origin?: string;
+}): AnnotateServerResult {
+  let resolveDecision!: (result: { feedback: string }) => void;
+  const decisionPromise = new Promise<{ feedback: string }>((r) => {
+    resolveDecision = r;
+  });
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url!, `http://localhost`);
+
+    if (url.pathname === "/api/plan" && req.method === "GET") {
+      json(res, {
+        plan: options.markdown,
+        origin: options.origin ?? "pi",
+        mode: "annotate",
+        filePath: options.filePath,
+      });
+    } else if (url.pathname === "/api/feedback" && req.method === "POST") {
+      const body = await parseBody(req);
+      resolveDecision({ feedback: (body.feedback as string) || "" });
+      json(res, { ok: true });
+    } else {
+      html(res, options.htmlContent);
+    }
+  });
+
+  const port = listenOnRandomPort(server);
+
+  return {
+    port,
+    url: `http://localhost:${port}`,
+    waitForDecision: () => decisionPromise,
+    stop: () => server.close(),
+  };
+}

package/utils.ts

@@ -0,0 +1,103 @@
+/**
+ * Plannotator Pi extension utilities.
+ *
+ * Inlined versions of bash safety checks and checklist parsing.
+ * (No access to pi-mono's plan-mode/utils at runtime.)
+ */
+
+// ── Bash Safety ──────────────────────────────────────────────────────────
+
+const DESTRUCTIVE_PATTERNS = [
+  /\brm\b/i, /\brmdir\b/i, /\bmv\b/i, /\bcp\b/i, /\bmkdir\b/i,
+  /\btouch\b/i, /\bchmod\b/i, /\bchown\b/i, /\bchgrp\b/i, /\bln\b/i,
+  /\btee\b/i, /\btruncate\b/i, /\bdd\b/i, /\bshred\b/i,
+  /(^|[^<])>(?!>)/, />>/,
+  /\bnpm\s+(install|uninstall|update|ci|link|publish)/i,
+  /\byarn\s+(add|remove|install|publish)/i,
+  /\bpnpm\s+(add|remove|install|publish)/i,
+  /\bpip\s+(install|uninstall)/i,
+  /\bapt(-get)?\s+(install|remove|purge|update|upgrade)/i,
+  /\bbrew\s+(install|uninstall|upgrade)/i,
+  /\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-[dD]|stash|cherry-pick|revert|tag|init|clone)/i,
+  /\bsudo\b/i, /\bsu\b/i, /\bkill\b/i, /\bpkill\b/i, /\bkillall\b/i,
+  /\breboot\b/i, /\bshutdown\b/i,
+  /\bsystemctl\s+(start|stop|restart|enable|disable)/i,
+  /\bservice\s+\S+\s+(start|stop|restart)/i,
+  /\b(vim?|nano|emacs|code|subl)\b/i,
+];
+
+const SAFE_PATTERNS = [
+  /^\s*cat\b/, /^\s*head\b/, /^\s*tail\b/, /^\s*less\b/, /^\s*more\b/,
+  /^\s*grep\b/, /^\s*find\b/, /^\s*ls\b/, /^\s*pwd\b/, /^\s*echo\b/,
+  /^\s*printf\b/, /^\s*wc\b/, /^\s*sort\b/, /^\s*uniq\b/, /^\s*diff\b/,
+  /^\s*file\b/, /^\s*stat\b/, /^\s*du\b/, /^\s*df\b/, /^\s*tree\b/,
+  /^\s*which\b/, /^\s*whereis\b/, /^\s*type\b/, /^\s*env\b/,
+  /^\s*printenv\b/, /^\s*uname\b/, /^\s*whoami\b/, /^\s*id\b/,
+  /^\s*date\b/, /^\s*cal\b/, /^\s*uptime\b/, /^\s*ps\b/,
+  /^\s*top\b/, /^\s*htop\b/, /^\s*free\b/,
+  /^\s*git\s+(status|log|diff|show|branch|remote|config\s+--get)/i,
+  /^\s*git\s+ls-/i,
+  /^\s*npm\s+(list|ls|view|info|search|outdated|audit)/i,
+  /^\s*yarn\s+(list|info|why|audit)/i,
+  /^\s*node\s+--version/i, /^\s*python\s+--version/i,
+  /^\s*curl\s/i, /^\s*wget\s+-O\s*-/i,
+  /^\s*jq\b/, /^\s*sed\s+-n/i, /^\s*awk\b/,
+  /^\s*rg\b/, /^\s*fd\b/, /^\s*bat\b/, /^\s*exa\b/,
+];
+
+export function isSafeCommand(command: string): boolean {
+  const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(command));
+  const isSafe = SAFE_PATTERNS.some((p) => p.test(command));
+  return !isDestructive && isSafe;
+}
+
+// ── Checklist Parsing ────────────────────────────────────────────────────
+
+export interface ChecklistItem {
+  /** 1-based step number, compatible with markCompletedSteps/extractDoneSteps. */
+  step: number;
+  text: string;
+  completed: boolean;
+}
+
+/**
+ * Parse standard markdown checkboxes from file content.
+ *
+ * Matches lines like:
+ *   - [ ] Step description
+ *   - [x] Completed step
+ *   * [ ] Alternative bullet
+ */
+export function parseChecklist(content: string): ChecklistItem[] {
+  const items: ChecklistItem[] = [];
+  const pattern = /^[-*]\s*\[([ xX])\]\s+(.+)$/gm;
+
+  for (const match of content.matchAll(pattern)) {
+    const completed = match[1] !== " ";
+    const text = match[2].trim();
+    if (text.length > 0) {
+      items.push({ step: items.length + 1, text, completed });
+    }
+  }
+  return items;
+}
+
+// ── Progress Tracking ────────────────────────────────────────────────────
+
+export function extractDoneSteps(message: string): number[] {
+  const steps: number[] = [];
+  for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
+    const step = Number(match[1]);
+    if (Number.isFinite(step)) steps.push(step);
+  }
+  return steps;
+}
+
+export function markCompletedSteps(text: string, items: ChecklistItem[]): number {
+  const doneSteps = extractDoneSteps(text);
+  for (const step of doneSteps) {
+    const item = items.find((t) => t.step === step);
+    if (item) item.completed = true;
+  }
+  return doneSteps.length;
+}