@ilya-lesikov/pi-pi 0.1.0

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

@@ -0,0 +1,262 @@
+/**
+ * Plannotator Config
+ *
+ * Reads/writes ~/.plannotator/config.json for persistent user settings.
+ * Runtime-agnostic: uses only node:fs, node:os, node:child_process.
+ */
+
+import { join } from "path";
+import { getPlannotatorDataDir } from "./data-dir";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { execSync } from "child_process";
+
+export type DefaultDiffType = 'uncommitted' | 'unstaged' | 'staged' | 'merge-base' | 'all';
+export type DiffLineBgIntensity = 'subtle' | 'normal' | 'strong';
+
+export interface DiffOptions {
+  diffStyle?: 'split' | 'unified';
+  overflow?: 'scroll' | 'wrap';
+  diffIndicators?: 'bars' | 'classic' | 'none';
+  lineDiffType?: 'word-alt' | 'word' | 'char' | 'none';
+  showLineNumbers?: boolean;
+  showDiffBackground?: boolean;
+  fontFamily?: string;
+  fontSize?: string;
+  tabSize?: number;
+  hideWhitespace?: boolean;
+  expandUnchanged?: boolean;
+  defaultDiffType?: DefaultDiffType;
+  lineBgIntensity?: DiffLineBgIntensity;
+}
+
+/** Single conventional comment label entry stored in config.json */
+export interface CCLabelConfig {
+  label: string;
+  display: string;
+  blocking: boolean;
+}
+
+export type PromptSectionOverrides = Record<string, string | undefined>;
+
+export type PromptRuntime =
+  | "claude-code"
+  | "amp"
+  | "droid"
+  | "kiro-cli"
+  | "opencode"
+  | "copilot-cli"
+  | "pi"
+  | "codex"
+  | "gemini-cli";
+
+interface PromptSectionConfig {
+  [key: string]: string | Partial<Record<PromptRuntime, PromptSectionOverrides>> | undefined;
+  runtimes?: Partial<Record<PromptRuntime, PromptSectionOverrides>>;
+}
+
+export interface PromptConfig {
+  review?: PromptSectionConfig & {
+    approved?: string;
+    denied?: string;
+  };
+  plan?: PromptSectionConfig & {
+    approved?: string;
+    approvedWithNotes?: string;
+    autoApproved?: string;
+    denied?: string;
+  };
+  annotate?: PromptSectionConfig & {
+    fileFeedback?: string;
+    messageFeedback?: string;
+    approved?: string;
+  };
+}
+
+const PROMPT_SECTIONS = ["review", "plan", "annotate"] as const;
+
+export function mergePromptConfig(
+  current?: PromptConfig,
+  partial?: PromptConfig,
+): PromptConfig | undefined {
+  if (!current && !partial) return undefined;
+
+  const result: Record<string, any> = { ...current, ...partial };
+
+  for (const section of PROMPT_SECTIONS) {
+    const cur = current?.[section];
+    const par = partial?.[section];
+    if (cur || par) {
+      result[section] = {
+        ...cur,
+        ...par,
+        runtimes: (cur?.runtimes || par?.runtimes)
+          ? { ...cur?.runtimes, ...par?.runtimes }
+          : undefined,
+      };
+    }
+  }
+
+  return result as PromptConfig;
+}
+
+export interface PlannotatorConfig {
+  displayName?: string;
+  diffOptions?: DiffOptions;
+  prompts?: PromptConfig;
+  conventionalComments?: boolean;
+  /** null = explicitly cleared (use defaults), undefined = not set */
+  conventionalLabels?: CCLabelConfig[] | null;
+  /**
+   * Enable `gh attestation verify` during CLI installation/upgrade.
+   * Read by scripts/install.sh|ps1|cmd on every run (not by any runtime code).
+   * When true, the installer runs build-provenance verification after the
+   * SHA256 checksum check; requires `gh` CLI installed and authenticated
+   * (`gh auth login`). OS-level opt-in only — no UI surface. Default: false.
+   */
+  verifyAttestation?: boolean;
+  /**
+   * Enable Jina Reader for URL-to-markdown conversion during annotation.
+   * When true (default), `plannotator annotate <url>` routes through
+   * r.jina.ai for better JS-rendered page support and reader-mode extraction.
+   * Set to false to always use plain fetch + Turndown.
+   */
+  jina?: boolean;
+  /**
+   * Inject a Plannotator Flavored Markdown reminder into every EnterPlanMode
+   * call so the agent is aware it can enrich plans with code-file links,
+   * callouts, tables, diagrams, task lists, and the other PFM extensions.
+   * Read by the `improve-context` PreToolUse handler. Default: false.
+   */
+  pfmReminder?: boolean;
+  /**
+   * Open Plannotator in a Glimpse native window when available.
+   * When true (default), the server spawns `glimpseui` if it is on PATH,
+   * no explicit browser is configured, and the session is local.
+   * Set to false to always use the system browser even when Glimpse is installed.
+   */
+  glimpse?: boolean;
+}
+
+const CONFIG_DIR = getPlannotatorDataDir();
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+/**
+ * Load config from ~/.plannotator/config.json.
+ * Returns {} on missing file or malformed JSON.
+ */
+export function loadConfig(): PlannotatorConfig {
+  try {
+    if (!existsSync(CONFIG_PATH)) return {};
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch (e) {
+    process.stderr.write(`[plannotator] Warning: failed to read config.json: ${e}\n`);
+    return {};
+  }
+}
+
+/**
+ * Save config by merging partial values into the existing file.
+ * Creates ~/.plannotator/ directory if needed.
+ */
+export function saveConfig(partial: Partial<PlannotatorConfig>): void {
+  try {
+    const current = loadConfig();
+    const mergedDiffOptions = (current.diffOptions || partial.diffOptions)
+      ? { ...current.diffOptions, ...partial.diffOptions }
+      : undefined;
+    const mergedPrompts = mergePromptConfig(current.prompts, partial.prompts);
+    const merged = {
+      ...current,
+      ...partial,
+      diffOptions: mergedDiffOptions,
+      prompts: mergedPrompts,
+    };
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  } catch (e) {
+    process.stderr.write(`[plannotator] Warning: failed to write config.json: ${e}\n`);
+  }
+}
+
+/**
+ * Detect the git user name from `git config user.name`.
+ * Returns null if git is unavailable, not in a repo, or user.name is not set.
+ */
+export function detectGitUser(): string | null {
+  try {
+    const name = execSync("git config user.name", { encoding: "utf-8", timeout: 3000 }).trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the serverConfig payload for API responses.
+ * Reads config.json fresh each call so the response reflects the latest file on disk.
+ */
+export function getServerConfig(gitUser: string | null): {
+  displayName?: string;
+  diffOptions?: DiffOptions;
+  gitUser?: string;
+  conventionalComments?: boolean;
+  conventionalLabels?: CCLabelConfig[] | null;
+} {
+  const cfg = loadConfig();
+  return {
+    displayName: cfg.displayName,
+    diffOptions: cfg.diffOptions,
+    gitUser: gitUser ?? undefined,
+    ...(cfg.conventionalComments !== undefined && { conventionalComments: cfg.conventionalComments }),
+    ...(cfg.conventionalLabels !== undefined && { conventionalLabels: cfg.conventionalLabels }),
+  };
+}
+
+/**
+ * Read the user's preferred default diff type from config, falling back to 'unstaged'.
+ */
+export function resolveDefaultDiffType(cfg?: PlannotatorConfig): DefaultDiffType {
+  const v = cfg?.diffOptions?.defaultDiffType as string | undefined;
+  if (v === 'branch') return 'merge-base';
+  return v === 'uncommitted' || v === 'unstaged' || v === 'staged' || v === 'merge-base' || v === 'all' ? v : 'unstaged';
+}
+
+/**
+ * Resolve whether to use Glimpse native window.
+ *
+ * Priority (highest wins):
+ *   PLANNOTATOR_GLIMPSE env var  →  config.glimpse  →  default true
+ */
+export function resolveUseGlimpse(config: PlannotatorConfig): boolean {
+  const envVal = process.env.PLANNOTATOR_GLIMPSE;
+  if (envVal !== undefined) {
+    return envVal === "1" || envVal.toLowerCase() === "true";
+  }
+  if (config.glimpse !== undefined) return config.glimpse;
+  return true;
+}
+
+/**
+ * Resolve whether to use Jina Reader for URL annotation.
+ *
+ * Priority (highest wins):
+ *   --no-jina CLI flag  →  PLANNOTATOR_JINA env var  →  config.jina  →  default true
+ */
+export function resolveUseJina(cliNoJina: boolean, config: PlannotatorConfig): boolean {
+  // CLI flag has highest priority
+  if (cliNoJina) return false;
+
+  // Environment variable
+  const envVal = process.env.PLANNOTATOR_JINA;
+  if (envVal !== undefined) {
+    return envVal === "1" || envVal.toLowerCase() === "true";
+  }
+
+  // Config file
+  if (config.jina !== undefined) return config.jina;
+
+  // Default: enabled
+  return true;
+}

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

@@ -0,0 +1,172 @@
+/**
+ * End-to-end encryption tests for the paste service.
+ *
+ * Tests the full pipeline: compress → encrypt → store → retrieve → decrypt → decompress
+ * Run: bun test packages/shared/crypto.test.ts
+ */
+
+import { describe, expect, test } from "bun:test";
+import { encrypt, decrypt } from "./crypto";
+import { deflateSync, inflateSync } from "bun";
+
+// Bun's test runner doesn't have CompressionStream (browser API).
+// Use Bun's native zlib for the same deflate-raw + base64url pipeline.
+function compress(data: unknown): string {
+  const json = JSON.stringify(data);
+  const compressed = deflateSync(new TextEncoder().encode(json));
+  let binary = "";
+  for (let i = 0; i < compressed.length; i++) {
+    binary += String.fromCharCode(compressed[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+function decompress(b64: string): unknown {
+  const base64 = b64.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(base64);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  const decompressed = inflateSync(bytes);
+  return JSON.parse(new TextDecoder().decode(decompressed));
+}
+
+const PASTE_API = "https://plannotator-paste.plannotator.workers.dev";
+
+// Realistic plan payload matching SharePayload shape
+const SAMPLE_PAYLOAD = {
+  p: "# Implementation Plan\n\n## Step 1: Add authentication\n\nWe'll use JWT tokens stored in httpOnly cookies.\n\n## Step 2: Create middleware\n\nAdd auth middleware to all protected routes.\n\n```typescript\nconst authMiddleware = async (req: Request) => {\n  const token = getCookie(req, 'auth');\n  if (!token) throw new UnauthorizedError();\n  return verify(token, SECRET);\n};\n```\n\n## Step 3: Update database schema\n\nAdd users table with email, password_hash, created_at columns.",
+  a: [
+    ["C", "Add auth middleware", "Consider rate limiting on login endpoint", "reviewer", []],
+    ["R", "JWT tokens stored in httpOnly cookies", "Use refresh token rotation instead of single JWT", null, []],
+    ["D", "Add users table with email, password_hash, created_at columns.", null, []],
+  ],
+};
+
+// --- Unit tests (no network) ---
+
+describe("encrypt / decrypt round-trip", () => {
+  test("encrypts and decrypts a string", async () => {
+    const plaintext = "hello world";
+    const { ciphertext, key } = await encrypt(plaintext);
+
+    expect(ciphertext).not.toBe(plaintext);
+    expect(key.length).toBeGreaterThan(0);
+
+    const decrypted = await decrypt(ciphertext, key);
+    expect(decrypted).toBe(plaintext);
+  });
+
+  test("each encryption produces a unique ciphertext (random IV)", async () => {
+    const plaintext = "same input";
+    const a = await encrypt(plaintext);
+    const b = await encrypt(plaintext);
+
+    expect(a.ciphertext).not.toBe(b.ciphertext);
+    expect(a.key).not.toBe(b.key);
+  });
+
+  test("wrong key fails to decrypt", async () => {
+    const { ciphertext } = await encrypt("secret");
+    const { key: wrongKey } = await encrypt("other");
+
+    expect(decrypt(ciphertext, wrongKey)).rejects.toThrow();
+  });
+
+  test("tampered ciphertext fails to decrypt", async () => {
+    const { ciphertext, key } = await encrypt("secret");
+
+    // Flip a character in the middle of the ciphertext
+    const mid = Math.floor(ciphertext.length / 2);
+    const tampered = ciphertext.slice(0, mid) +
+      (ciphertext[mid] === 'A' ? 'B' : 'A') +
+      ciphertext.slice(mid + 1);
+
+    expect(decrypt(tampered, key)).rejects.toThrow();
+  });
+
+  test("handles large payloads", async () => {
+    const large = "x".repeat(100_000);
+    const { ciphertext, key } = await encrypt(large);
+    const decrypted = await decrypt(ciphertext, key);
+    expect(decrypted).toBe(large);
+  });
+});
+
+describe("full pipeline: compress → encrypt → decrypt → decompress", () => {
+  test("round-trips a SharePayload", async () => {
+    const compressed = await compress(SAMPLE_PAYLOAD);
+    const { ciphertext, key } = await encrypt(compressed);
+
+    // Ciphertext should not contain the original plan text
+    expect(ciphertext).not.toContain("Implementation Plan");
+
+    const decrypted = await decrypt(ciphertext, key);
+    const decompressed = await decompress(decrypted);
+
+    expect(decompressed).toEqual(SAMPLE_PAYLOAD);
+  });
+});
+
+// --- Integration tests (hit live paste service) ---
+
+describe("live paste service E2E", () => {
+  test("encrypt → POST → GET → decrypt → decompress", async () => {
+    // 1. Compress
+    const compressed = await compress(SAMPLE_PAYLOAD);
+
+    // 2. Encrypt
+    const { ciphertext, key } = await encrypt(compressed);
+
+    // 3. Store — server sees only ciphertext
+    const postRes = await fetch(`${PASTE_API}/api/paste`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ data: ciphertext }),
+    });
+    expect(postRes.status).toBe(201);
+    const { id } = (await postRes.json()) as { id: string };
+    expect(id).toMatch(/^[A-Za-z0-9]{8}$/);
+
+    // 4. Retrieve
+    const getRes = await fetch(`${PASTE_API}/api/paste/${id}`);
+    expect(getRes.status).toBe(200);
+
+    // Verify Cache-Control header
+    expect(getRes.headers.get("cache-control")).toBe("private, no-store");
+
+    const { data: storedData } = (await getRes.json()) as { data: string };
+
+    // 5. Verify server stores only ciphertext (not readable plan data)
+    expect(storedData).toBe(ciphertext);
+    expect(storedData).not.toContain("Implementation Plan");
+
+    // 6. Decrypt
+    const decrypted = await decrypt(storedData, key);
+
+    // 7. Decompress
+    const result = await decompress(decrypted);
+    expect(result).toEqual(SAMPLE_PAYLOAD);
+  });
+
+  test("GET without key returns opaque ciphertext", async () => {
+    const compressed = await compress({ p: "secret plan", a: [] });
+    const { ciphertext } = await encrypt(compressed);
+
+    const postRes = await fetch(`${PASTE_API}/api/paste`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ data: ciphertext }),
+    });
+    const { id } = (await postRes.json()) as { id: string };
+
+    const getRes = await fetch(`${PASTE_API}/api/paste/${id}`);
+    const { data } = (await getRes.json()) as { data: string };
+
+    // Data is opaque — cannot be decompressed without decryption
+    expect(() => decompress(data)).toThrow();
+  });
+
+  test("expired/nonexistent paste returns 404", async () => {
+    const res = await fetch(`${PASTE_API}/api/paste/ZZZZZZZZ`);
+    expect(res.status).toBe(404);
+  });
+});

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

@@ -0,0 +1,97 @@
+/**
+ * AES-256-GCM encryption for zero-knowledge paste storage.
+ *
+ * Uses Web Crypto API — works in browsers, Bun, and edge runtimes.
+ * The key never leaves the client; it lives in the URL fragment.
+ */
+
+/**
+ * Encrypt a compressed base64url string with a fresh AES-256-GCM key.
+ *
+ * Returns { ciphertext, key } where:
+ * - ciphertext: base64url-encoded (12-byte IV prepended to GCM output)
+ * - key: base64url-encoded 256-bit key for the URL fragment
+ */
+export async function encrypt(
+  compressedData: string
+): Promise<{ ciphertext: string; key: string }> {
+  const cryptoKey = await crypto.subtle.generateKey(
+    { name: 'AES-GCM', length: 256 },
+    true,
+    ['encrypt']
+  );
+
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const plaintext = new TextEncoder().encode(compressedData);
+
+  const encrypted = await crypto.subtle.encrypt(
+    { name: 'AES-GCM', iv },
+    cryptoKey,
+    plaintext
+  );
+
+  // Prepend IV to ciphertext (IV || ciphertext+tag)
+  const combined = new Uint8Array(iv.length + encrypted.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(encrypted), iv.length);
+
+  const rawKey = await crypto.subtle.exportKey('raw', cryptoKey);
+
+  return {
+    ciphertext: bytesToBase64url(combined),
+    key: bytesToBase64url(new Uint8Array(rawKey)),
+  };
+}
+
+/**
+ * Decrypt a ciphertext string using a base64url-encoded AES-256-GCM key.
+ *
+ * Expects ciphertext format: base64url(IV || encrypted+tag)
+ * Returns the original compressed base64url string.
+ */
+export async function decrypt(
+  ciphertext: string,
+  key: string
+): Promise<string> {
+  const combined = base64urlToBytes(ciphertext);
+  const rawKey = base64urlToBytes(key);
+
+  const iv = combined.slice(0, 12);
+  const encrypted = combined.slice(12);
+
+  const cryptoKey = await crypto.subtle.importKey(
+    'raw',
+    rawKey.buffer as ArrayBuffer,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['decrypt']
+  );
+
+  const decrypted = await crypto.subtle.decrypt(
+    { name: 'AES-GCM', iv },
+    cryptoKey,
+    encrypted
+  );
+
+  return new TextDecoder().decode(decrypted);
+}
+
+// --- Helpers ---
+
+function bytesToBase64url(bytes: Uint8Array): string {
+  // Loop to avoid RangeError on large payloads (same approach as compress.ts)
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=/g, '');
+}
+
+function base64urlToBytes(b64: string): Uint8Array {
+  const base64 = b64.replace(/-/g, '+').replace(/_/g, '/');
+  const binary = atob(base64);
+  return Uint8Array.from(binary, c => c.charCodeAt(0));
+}

package/3p/pi-plannotator/packages/shared/data-dir.ts

@@ -0,0 +1,42 @@
+/**
+ * Plannotator Data Directory
+ *
+ * Returns the base directory for all Plannotator data files.
+ *
+ * Priority:
+ *   1.  PLANNOTATOR_DATA_DIR environment variable (with ~ expansion)
+ *   2.  Default: ~/.plannotator
+ *
+ * This mirrors PASTE_DATA_DIR for the paste service and allows users
+ * to relocate all data (plans, history, drafts, config, hooks, sessions,
+ * debug logs, IPC registry, etc.) via a single variable — useful for
+ * XDG-style home directory cleanliness on Unix systems.
+ */
+
+import { homedir } from "os";
+import { join, resolve } from "path";
+
+/**
+ * Resolve the Plannotator data directory.
+ *
+ * If PLANNOTATOR_DATA_DIR is set and non-empty, the value is used
+ * as the base directory. Leading ~ is expanded to the user's home
+ * directory.
+ *
+ * Falls back to ~/.plannotator when the env var is absent or empty.
+ */
+export function getPlannotatorDataDir(): string {
+  const envDir = process.env.PLANNOTATOR_DATA_DIR?.trim();
+  if (!envDir) {
+    return join(homedir(), ".plannotator");
+  }
+
+  // Expand ~ to home directory
+  const home = homedir();
+  if (envDir === "~") return home;
+  if (envDir.startsWith("~/") || envDir.startsWith("~\\")) {
+    return join(home, envDir.slice(2));
+  }
+
+  return resolve(envDir);
+}

package/3p/pi-plannotator/packages/shared/diff-paths.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { parseDiffFilePathLines, parsePatchPathToken } from "./diff-paths";
+
+describe("diff path parsing", () => {
+  test("strips tab metadata from unquoted file path lines", () => {
+    expect(parseDiffFilePathLines([
+      "--- a/my file\t",
+      "+++ b/my file\t",
+      "@@ -1 +1 @@",
+    ])).toEqual({
+      oldPath: "my file",
+      newPath: "my file",
+    });
+  });
+
+  test("preserves escaped tabs inside quoted file paths", () => {
+    expect(parseDiffFilePathLines([
+      '--- "a/my\\tfile"',
+      '+++ "b/my\\tfile"',
+      "@@ -1 +1 @@",
+    ])).toEqual({
+      oldPath: "my\tfile",
+      newPath: "my\tfile",
+    });
+  });
+
+  test("preserves dev null paths with tab metadata", () => {
+    expect(parsePatchPathToken("/dev/null\t", "a")).toBe("/dev/null");
+  });
+});