@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/packages/server/git.ts

@@ -0,0 +1,141 @@
+/**
+ * Git utilities for code review
+ *
+ * Centralized git operations for diff collection and branch detection.
+ * Used by both Claude Code hook and OpenCode plugin.
+ */
+
+import {
+  type DiffOption,
+  type DiffResult,
+  type DiffType,
+  type GitCommandResult,
+  type GitContext,
+  type GitDiffOptions,
+  type ReviewGitRuntime,
+  type WorktreeInfo,
+  getCurrentBranch as getCurrentBranchCore,
+  getDefaultBranch as getDefaultBranchCore,
+  getWorktrees as getWorktreesCore,
+  getGitContext as getGitContextCore,
+  getFileContentsForDiff as getFileContentsForDiffCore,
+  gitAddFile as gitAddFileCore,
+  gitResetFile as gitResetFileCore,
+  parseWorktreeDiffType,
+  runGitDiff as runGitDiffCore,
+  runGitDiffWithContext as runGitDiffWithContextCore,
+  validateFilePath,
+} from "@plannotator/shared/review-core";
+
+export type {
+  DiffOption,
+  DiffType,
+  DiffResult,
+  GitContext,
+  GitDiffOptions,
+  WorktreeInfo,
+} from "@plannotator/shared/review-core";
+
+async function runGit(
+  args: string[],
+  options?: { cwd?: string; timeoutMs?: number },
+): Promise<GitCommandResult> {
+  const proc = Bun.spawn(["git", "-c", "core.quotePath=false", ...args], {
+    cwd: options?.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  if (options?.timeoutMs) {
+    timer = setTimeout(() => proc.kill(), options.timeoutMs);
+  }
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  if (timer) clearTimeout(timer);
+
+  return { stdout, stderr, exitCode };
+}
+
+/** Bun-based git runtime. Exported for use with shared utilities (worktree, etc.) */
+export const runtime: ReviewGitRuntime = {
+  runGit,
+  async readTextFile(path: string): Promise<string | null> {
+    try {
+      return await Bun.file(path).text();
+    } catch {
+      return null;
+    }
+  },
+};
+
+export function getCurrentBranch(): Promise<string> {
+  return getCurrentBranchCore(runtime);
+}
+
+export function getDefaultBranch(): Promise<string> {
+  return getDefaultBranchCore(runtime);
+}
+
+export function getWorktrees(): Promise<WorktreeInfo[]> {
+  return getWorktreesCore(runtime);
+}
+
+export function getGitContext(cwd?: string): Promise<GitContext> {
+  return getGitContextCore(runtime, cwd);
+}
+
+export function runGitDiff(
+  diffType: DiffType,
+  defaultBranch: string = "main",
+  cwd?: string,
+  options?: GitDiffOptions,
+): Promise<DiffResult> {
+  return runGitDiffCore(runtime, diffType, defaultBranch, cwd, options);
+}
+
+export function runGitDiffWithContext(
+  diffType: DiffType,
+  gitContext: GitContext,
+  options?: GitDiffOptions,
+): Promise<DiffResult> {
+  return runGitDiffWithContextCore(runtime, diffType, gitContext, options);
+}
+
+export function getFileContentsForDiff(
+  diffType: DiffType,
+  defaultBranch: string,
+  filePath: string,
+  oldPath?: string,
+  cwd?: string,
+): Promise<{ oldContent: string | null; newContent: string | null }> {
+  return getFileContentsForDiffCore(
+    runtime,
+    diffType,
+    defaultBranch,
+    filePath,
+    oldPath,
+    cwd,
+  );
+}
+
+export function gitAddFile(
+  filePath: string,
+  cwd?: string,
+): Promise<void> {
+  return gitAddFileCore(runtime, filePath, cwd);
+}
+
+export function gitResetFile(
+  filePath: string,
+  cwd?: string,
+): Promise<void> {
+  return gitResetFileCore(runtime, filePath, cwd);
+}
+
+export { parseWorktreeDiffType, validateFilePath };

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

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { normalizeGoalSetupBundle } from "@plannotator/shared/goal-setup";
+import { startGoalSetupServer, type GoalSetupServerResult } from "./goal-setup";
+
+let server: GoalSetupServerResult | null = null;
+
+afterEach(() => {
+  server?.stop();
+  server = null;
+});
+
+describe("goal setup server", () => {
+  test("serves interview bundle and resolves submitted answers", async () => {
+    const bundle = normalizeGoalSetupBundle({
+      stage: "interview",
+      title: "Goal setup",
+      questions: [{ id: "scope", prompt: "Scope?" }],
+    });
+
+    server = await startGoalSetupServer({
+      bundle,
+      htmlContent: "<html></html>",
+      origin: "claude-code",
+    });
+
+    const plan = await fetch(`${server.url}/api/goal-setup`).then((res) =>
+      res.json()
+    );
+    expect(plan.mode).toBe("goal-setup");
+    expect(plan.goalSetup.questions[0].id).toBe("scope");
+
+    const decision = server.waitForDecision();
+    const submitted = await fetch(`${server.url}/api/goal-setup/submit`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        answers: [
+          {
+            questionId: "scope",
+            selectedOptionIds: [],
+            customAnswer: "",
+            answer: "UI, server, and skill text.",
+            completed: true,
+          },
+        ],
+      }),
+    }).then((res) => res.json());
+
+    expect(submitted.ok).toBe(true);
+    const result = await decision;
+    expect(result.result?.stage).toBe("interview");
+    if (result.result?.stage !== "interview") throw new Error("expected interview");
+    expect(result.result.answers[0].answer).toBe("UI, server, and skill text.");
+  });
+});

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

@@ -0,0 +1,248 @@
+/**
+ * Goal Setup Server
+ *
+ * Serves the Plannotator shell in a goal-setup mode for the setup-goal skill.
+ * The interview and facts phases use the same endpoint surface so agents can
+ * launch a browser session, wait, and receive a structured JSON result.
+ */
+
+import type { Origin } from "@plannotator/shared/agents";
+import {
+  createFactsResult,
+  createInterviewResult,
+  type GoalSetupBundle,
+  type GoalSetupFactResult,
+  type GoalSetupQuestionAnswer,
+  type GoalSetupResult,
+} from "@plannotator/shared/goal-setup";
+import { isRemoteSession, getServerHostname, getServerPort } from "./remote";
+import { getRepoInfo } from "./repo";
+import {
+  handleFavicon,
+  handleImage,
+  handleServerReady,
+  handleUpload,
+} from "./shared-handlers";
+import { detectGitUser, getServerConfig, saveConfig } from "./config";
+import { isWSL } from "./browser";
+
+export { handleServerReady as handleGoalSetupServerReady } from "./shared-handlers";
+
+export interface GoalSetupServerOptions {
+  bundle: GoalSetupBundle;
+  htmlContent: string;
+  origin?: Origin;
+  onReady?: (url: string, isRemote: boolean, port: number) => void;
+}
+
+export interface GoalSetupServerResult {
+  port: number;
+  url: string;
+  isRemote: boolean;
+  waitForDecision: () => Promise<{
+    result?: GoalSetupResult;
+    exit?: boolean;
+  }>;
+  stop: () => void;
+}
+
+const MAX_RETRIES = 5;
+const RETRY_DELAY_MS = 500;
+
+function coerceAnswers(body: unknown): GoalSetupQuestionAnswer[] {
+  if (!body || typeof body !== "object") return [];
+  const record = body as Record<string, unknown>;
+  const answers = Array.isArray(record.answers)
+    ? record.answers
+    : record.result &&
+        typeof record.result === "object" &&
+        Array.isArray((record.result as Record<string, unknown>).answers)
+      ? ((record.result as Record<string, unknown>).answers as unknown[])
+      : [];
+  return answers as GoalSetupQuestionAnswer[];
+}
+
+function coerceFacts(body: unknown): GoalSetupFactResult[] {
+  if (!body || typeof body !== "object") return [];
+  const record = body as Record<string, unknown>;
+  const facts = Array.isArray(record.facts)
+    ? record.facts
+    : record.result &&
+        typeof record.result === "object" &&
+        Array.isArray((record.result as Record<string, unknown>).facts)
+      ? ((record.result as Record<string, unknown>).facts as unknown[])
+      : [];
+  return facts as GoalSetupFactResult[];
+}
+
+export async function startGoalSetupServer(
+  options: GoalSetupServerOptions
+): Promise<GoalSetupServerResult> {
+  const { bundle, htmlContent, origin = "claude-code", onReady } = options;
+  const isRemote = isRemoteSession();
+  const configuredPort = getServerPort();
+  const wslFlag = await isWSL();
+  const repoInfo = await getRepoInfo();
+  const gitUser = detectGitUser();
+
+  let settled = false;
+  let resolveDecision: (result: {
+    result?: GoalSetupResult;
+    exit?: boolean;
+  }) => void;
+  const decisionPromise = new Promise<{
+    result?: GoalSetupResult;
+    exit?: boolean;
+  }>((resolve) => {
+    resolveDecision = resolve;
+  });
+
+  const resolveOnce = (result: { result?: GoalSetupResult; exit?: boolean }) => {
+    if (settled) return;
+    settled = true;
+    resolveDecision(result);
+  };
+
+  let server: ReturnType<typeof Bun.serve> | null = null;
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      server = Bun.serve({
+        hostname: getServerHostname(),
+        port: configuredPort,
+
+        async fetch(req) {
+          const url = new URL(req.url);
+
+          if (
+            (url.pathname === "/api/plan" ||
+              url.pathname === "/api/goal-setup") &&
+            req.method === "GET"
+          ) {
+            return Response.json({
+              plan: "",
+              origin,
+              mode: "goal-setup",
+              goalSetup: bundle,
+              repoInfo,
+              projectRoot: process.cwd(),
+              isWSL: wslFlag,
+              serverConfig: getServerConfig(gitUser),
+              sharingEnabled: false,
+            });
+          }
+
+          if (url.pathname === "/api/config" && req.method === "POST") {
+            try {
+              const body = (await req.json()) as {
+                displayName?: string;
+                diffOptions?: Record<string, unknown>;
+                conventionalComments?: boolean;
+                conventionalLabels?: unknown[] | null;
+              };
+              const toSave: Record<string, unknown> = {};
+              if (body.displayName !== undefined) {
+                toSave.displayName = body.displayName;
+              }
+              if (body.diffOptions !== undefined) {
+                toSave.diffOptions = body.diffOptions;
+              }
+              if (body.conventionalComments !== undefined) {
+                toSave.conventionalComments = body.conventionalComments;
+              }
+              if (body.conventionalLabels !== undefined) {
+                toSave.conventionalLabels = body.conventionalLabels;
+              }
+              if (Object.keys(toSave).length > 0) {
+                saveConfig(toSave as Parameters<typeof saveConfig>[0]);
+              }
+              return Response.json({ ok: true });
+            } catch {
+              return Response.json({ error: "Invalid request" }, { status: 400 });
+            }
+          }
+
+          if (url.pathname === "/api/image") return handleImage(req);
+          if (url.pathname === "/api/upload" && req.method === "POST") {
+            return handleUpload(req);
+          }
+
+          if (
+            url.pathname === "/api/goal-setup/submit" &&
+            req.method === "POST"
+          ) {
+            try {
+              const body = await req.json();
+              const result =
+                bundle.stage === "interview"
+                  ? createInterviewResult(bundle, coerceAnswers(body))
+                  : createFactsResult(bundle, coerceFacts(body));
+              resolveOnce({ result });
+              return Response.json({ ok: true, result });
+            } catch (err) {
+              const message =
+                err instanceof Error ? err.message : "Failed to submit result";
+              return Response.json({ error: message }, { status: 400 });
+            }
+          }
+
+          if (url.pathname === "/api/exit" && req.method === "POST") {
+            resolveOnce({ exit: true });
+            return Response.json({ ok: true });
+          }
+
+          if (url.pathname === "/favicon.svg") return handleFavicon();
+
+          return new Response(htmlContent, {
+            headers: { "Content-Type": "text/html" },
+          });
+        },
+
+        error(err) {
+          console.error("[plannotator] Goal setup server error:", err);
+          return new Response(
+            `Internal Server Error: ${err instanceof Error ? err.message : String(err)}`,
+            { status: 500, headers: { "Content-Type": "text/plain" } }
+          );
+        },
+      });
+
+      break;
+    } catch (err: unknown) {
+      const isAddressInUse =
+        err instanceof Error && err.message.includes("EADDRINUSE");
+
+      if (isAddressInUse && attempt < MAX_RETRIES) {
+        await Bun.sleep(RETRY_DELAY_MS);
+        continue;
+      }
+
+      if (isAddressInUse) {
+        const hint = isRemote
+          ? " (set PLANNOTATOR_PORT to use different port)"
+          : "";
+        throw new Error(
+          `Port ${configuredPort} in use after ${MAX_RETRIES} retries${hint}`
+        );
+      }
+
+      throw err;
+    }
+  }
+
+  if (!server) {
+    throw new Error("Failed to start goal setup server");
+  }
+
+  const port = server.port!;
+  const serverUrl = `http://localhost:${port}`;
+  onReady?.(serverUrl, isRemote, port);
+
+  return {
+    port,
+    url: serverUrl,
+    isRemote,
+    waitForDecision: () => decisionPromise,
+    stop: () => server.stop(),
+  };
+}

package/3p/pi-plannotator/packages/server/ide.ts

@@ -0,0 +1,43 @@
+/**
+ * IDE integration — opens plan diffs in external IDEs
+ */
+
+/**
+ * Open two files in VS Code's diff viewer.
+ *
+ * Returns `{ ok: true }` on success or `{ error: string }` on failure.
+ */
+export async function openEditorDiff(
+  oldPath: string,
+  newPath: string
+): Promise<{ ok: true } | { error: string }> {
+  try {
+    const proc = Bun.spawn(["code", "--diff", oldPath, newPath], {
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      if (stderr.includes("not found") || stderr.includes("ENOENT")) {
+        return {
+          error:
+            "VS Code CLI not found. Run 'Shell Command: Install code command in PATH' from the VS Code command palette.",
+        };
+      }
+      return { error: `code --diff exited with ${exitCode}: ${stderr}` };
+    }
+
+    return { ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to open diff";
+    if (msg.includes("ENOENT") || msg.includes("not found")) {
+      return {
+        error:
+          "VS Code CLI not found. Run 'Shell Command: Install code command in PATH' from the VS Code command palette.",
+      };
+    }
+    return { error: msg };
+  }
+}

package/3p/pi-plannotator/packages/server/image.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Image Validation Tests
+ *
+ * Run: bun test packages/server/image.test.ts
+ */
+
+import { describe, expect, test } from "bun:test";
+import { tmpdir } from "node:os";
+import { validateImagePath, validateUploadExtension, UPLOAD_DIR } from "./image";
+
+describe("UPLOAD_DIR", () => {
+  test("uses os.tmpdir(), not hardcoded /tmp", () => {
+    // On macOS tmpdir() returns something like /var/folders/...
+    // On Linux it returns /tmp
+    // On Windows it returns C:\Users\...\AppData\Local\Temp
+    // The key thing: it should NOT be hardcoded to /tmp/plannotator
+    expect(UPLOAD_DIR).toContain("plannotator");
+    expect(UPLOAD_DIR.startsWith(tmpdir())).toBe(true);
+  });
+});
+
+describe("validateImagePath", () => {
+  test("accepts supported extensions", () => {
+    for (const ext of ["png", "jpg", "jpeg", "gif", "webp", "svg", "avif"]) {
+      const result = validateImagePath(`/tmp/image.${ext}`);
+      expect(result.valid).toBe(true);
+    }
+  });
+
+  test("rejects unsupported extensions", () => {
+    expect(validateImagePath("/tmp/file.txt").valid).toBe(false);
+    expect(validateImagePath("/tmp/script.js").valid).toBe(false);
+    expect(validateImagePath("/tmp/page.html").valid).toBe(false);
+  });
+
+  test("rejects files with no extension", () => {
+    expect(validateImagePath("/tmp/noextension").valid).toBe(false);
+  });
+
+  test("resolves path", () => {
+    const result = validateImagePath("relative/image.png");
+    expect(result.resolved).toMatch(/^\//); // absolute on POSIX
+  });
+});
+
+describe("validateUploadExtension", () => {
+  test("accepts supported extensions", () => {
+    expect(validateUploadExtension("photo.png").valid).toBe(true);
+    expect(validateUploadExtension("photo.jpg").valid).toBe(true);
+  });
+
+  test("rejects unsupported extensions", () => {
+    const result = validateUploadExtension("file.exe");
+    expect(result.valid).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  test("defaults to png when no extension", () => {
+    const result = validateUploadExtension("noext");
+    expect(result.valid).toBe(true);
+    expect(result.ext).toBe("png");
+  });
+});

package/3p/pi-plannotator/packages/server/image.ts

@@ -0,0 +1,66 @@
+import { resolve, join } from "path";
+import { tmpdir } from "os";
+
+const ALLOWED_IMAGE_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "svg",
+  "bmp",
+  "ico",
+  "tiff",
+  "tif",
+  "avif",
+]);
+
+const UPLOAD_DIR = join(tmpdir(), "plannotator");
+
+function getExtension(filePath: string): string {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) return "";
+  return filePath.slice(lastDot + 1).toLowerCase();
+}
+
+function hasImageExtension(filePath: string): boolean {
+  return ALLOWED_IMAGE_EXTENSIONS.has(getExtension(filePath));
+}
+
+export function validateImagePath(rawPath: string): {
+  valid: boolean;
+  resolved: string;
+  error?: string;
+} {
+  const resolved = resolve(rawPath);
+
+  if (!hasImageExtension(resolved)) {
+    return {
+      valid: false,
+      resolved,
+      error: "Path does not point to a supported image file",
+    };
+  }
+
+  return { valid: true, resolved };
+}
+
+export function validateUploadExtension(fileName: string): {
+  valid: boolean;
+  ext: string;
+  error?: string;
+} {
+  const ext = getExtension(fileName) || "png";
+
+  if (!ALLOWED_IMAGE_EXTENSIONS.has(ext)) {
+    return {
+      valid: false,
+      ext,
+      error: `File extension ".${ext}" is not a supported image type`,
+    };
+  }
+
+  return { valid: true, ext };
+}
+
+export { UPLOAD_DIR };