@ilya-lesikov/pi-pi 0.1.0

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

@@ -0,0 +1,150 @@
+/**
+ * Remote Detection & Port Config Tests
+ *
+ * Run: bun test packages/server/remote.test.ts
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { isRemoteSession, getServerHostname, getServerPort } from "./remote";
+
+// Save and restore env between tests
+const savedEnv: Record<string, string | undefined> = {};
+const envKeys = ["PLANNOTATOR_REMOTE", "PLANNOTATOR_PORT", "SSH_TTY", "SSH_CONNECTION"];
+
+function clearEnv() {
+  for (const key of envKeys) {
+    savedEnv[key] = process.env[key];
+    delete process.env[key];
+  }
+}
+
+afterEach(() => {
+  for (const key of envKeys) {
+    if (savedEnv[key] !== undefined) {
+      process.env[key] = savedEnv[key];
+    } else {
+      delete process.env[key];
+    }
+  }
+});
+
+describe("isRemoteSession", () => {
+  test("false by default (no env vars)", () => {
+    clearEnv();
+    expect(isRemoteSession()).toBe(false);
+  });
+
+  test("true when PLANNOTATOR_REMOTE=1", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "1";
+    expect(isRemoteSession()).toBe(true);
+  });
+
+  test("true when PLANNOTATOR_REMOTE=true", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "true";
+    expect(isRemoteSession()).toBe(true);
+  });
+
+  test("false when PLANNOTATOR_REMOTE=0", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "0";
+    expect(isRemoteSession()).toBe(false);
+  });
+
+  test("false when PLANNOTATOR_REMOTE=false", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "false";
+    expect(isRemoteSession()).toBe(false);
+  });
+
+  test("PLANNOTATOR_REMOTE=false overrides SSH_TTY", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "false";
+    process.env.SSH_TTY = "/dev/pts/0";
+    expect(isRemoteSession()).toBe(false);
+  });
+
+  test("PLANNOTATOR_REMOTE=0 overrides SSH_CONNECTION", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "0";
+    process.env.SSH_CONNECTION = "192.168.1.1 12345 192.168.1.2 22";
+    expect(isRemoteSession()).toBe(false);
+  });
+
+  test("true when SSH_TTY is set (legacy)", () => {
+    clearEnv();
+    process.env.SSH_TTY = "/dev/pts/0";
+    expect(isRemoteSession()).toBe(true);
+  });
+
+  test("true when SSH_CONNECTION is set (legacy)", () => {
+    clearEnv();
+    process.env.SSH_CONNECTION = "192.168.1.1 12345 192.168.1.2 22";
+    expect(isRemoteSession()).toBe(true);
+  });
+});
+
+describe("getServerPort", () => {
+  test("returns 0 for local session (random port)", () => {
+    clearEnv();
+    expect(getServerPort()).toBe(0);
+  });
+
+  test("returns 19432 for remote session", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "1";
+    expect(getServerPort()).toBe(19432);
+  });
+
+  test("returns 0 when PLANNOTATOR_REMOTE=false overrides SSH", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "false";
+    process.env.SSH_TTY = "/dev/pts/0";
+    expect(getServerPort()).toBe(0);
+  });
+
+  test("explicit PLANNOTATOR_PORT overrides everything", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_PORT = "8080";
+    expect(getServerPort()).toBe(8080);
+  });
+
+  test("explicit port overrides remote default", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "1";
+    process.env.PLANNOTATOR_PORT = "3000";
+    expect(getServerPort()).toBe(3000);
+  });
+
+  test("ignores invalid port (falls back to default)", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_PORT = "not-a-number";
+    expect(getServerPort()).toBe(0);
+  });
+
+  test("ignores out-of-range port", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_PORT = "99999";
+    expect(getServerPort()).toBe(0);
+  });
+
+  test("ignores zero port", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_PORT = "0";
+    expect(getServerPort()).toBe(0);
+  });
+});
+
+describe("getServerHostname", () => {
+  test("returns loopback for local sessions", () => {
+    clearEnv();
+    expect(getServerHostname()).toBe("127.0.0.1");
+  });
+
+  test("returns all interfaces for remote sessions", () => {
+    clearEnv();
+    process.env.PLANNOTATOR_REMOTE = "1";
+    expect(getServerHostname()).toBe("0.0.0.0");
+  });
+});

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

@@ -0,0 +1,74 @@
+/**
+ * Remote session detection and port configuration
+ *
+ * Environment variables:
+ *   PLANNOTATOR_REMOTE - Set to "1"/"true" to force remote, "0"/"false" to force local
+ *   PLANNOTATOR_PORT   - Fixed port to use (default: random locally, 19432 for remote)
+ *
+ * Legacy (still supported): SSH_TTY, SSH_CONNECTION
+ */
+
+const DEFAULT_REMOTE_PORT = 19432;
+const LOOPBACK_HOST = "127.0.0.1";
+
+function getRemoteOverride(): boolean | null {
+  const remote = process.env.PLANNOTATOR_REMOTE;
+  if (remote === undefined) {
+    return null;
+  }
+
+  if (remote === "1" || remote?.toLowerCase() === "true") {
+    return true;
+  }
+
+  if (remote === "0" || remote?.toLowerCase() === "false") {
+    return false;
+  }
+
+  return null;
+}
+
+/**
+ * Check if running in a remote session (SSH, devcontainer, etc.)
+ */
+export function isRemoteSession(): boolean {
+  const remoteOverride = getRemoteOverride();
+  if (remoteOverride !== null) {
+    return remoteOverride;
+  }
+
+  // Legacy: SSH_TTY/SSH_CONNECTION (deprecated, silent)
+  if (process.env.SSH_TTY || process.env.SSH_CONNECTION) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get the server port to use
+ */
+export function getServerPort(): number {
+  // Explicit port from environment takes precedence
+  const envPort = process.env.PLANNOTATOR_PORT;
+  if (envPort) {
+    const parsed = parseInt(envPort, 10);
+    if (!isNaN(parsed) && parsed >= 0 && parsed < 65536) {
+      return parsed;
+    }
+    console.error(
+      `[Plannotator] Warning: Invalid PLANNOTATOR_PORT "${envPort}", using default`
+    );
+  }
+
+  // Remote sessions use fixed port for port forwarding; local uses random
+  return isRemoteSession() ? DEFAULT_REMOTE_PORT : 0;
+}
+
+/**
+ * Bind local sessions to loopback, but keep remote sessions reachable via the
+ * container or host network interface for SSH/devcontainer/Docker forwarding.
+ */
+export function getServerHostname(): string {
+  return isRemoteSession() ? "0.0.0.0" : LOOPBACK_HOST;
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Repository Info Detection
+ *
+ * Detects org/repo from git remote with fallback chain.
+ * Priority: org/repo from remote → repo name → directory name
+ */
+
+import { $ } from "bun";
+
+import type { RepoInfo } from "@plannotator/shared/repo";
+import { parseRemoteUrl, parseRemoteHost, getDirName } from "@plannotator/shared/repo";
+
+/**
+ * Get current git branch
+ */
+async function getCurrentBranch(): Promise<string | undefined> {
+	try {
+		const result = await $`git rev-parse --abbrev-ref HEAD`.quiet().nothrow();
+		if (result.exitCode === 0) {
+			const branch = result.stdout.toString().trim();
+			return branch && branch !== "HEAD" ? branch : undefined;
+		}
+	} catch {
+		// Not in a git repo
+	}
+	return undefined;
+}
+
+/**
+ * Detect repository info with fallback chain
+ *
+ * 1. Try org/repo from git remote origin
+ * 2. Fall back to git repo root directory name
+ * 3. Fall back to current working directory name
+ */
+export async function getRepoInfo(): Promise<RepoInfo | null> {
+	let branch: string | undefined;
+
+	// Try git remote URL first
+	try {
+		const result = await $`git remote get-url origin`.quiet().nothrow();
+		if (result.exitCode === 0) {
+			const remoteUrl = result.stdout.toString().trim();
+			const orgRepo = parseRemoteUrl(remoteUrl);
+			if (orgRepo) {
+				branch = await getCurrentBranch();
+				const host = parseRemoteHost(remoteUrl) ?? undefined;
+				return { display: orgRepo, branch, host };
+			}
+		}
+	} catch {
+		// Git not available
+	}
+
+	// Fallback: git repo root name
+	try {
+		const result = await $`git rev-parse --show-toplevel`.quiet().nothrow();
+		if (result.exitCode === 0) {
+			const repoName = getDirName(result.stdout.toString());
+			if (repoName) {
+				branch = await getCurrentBranch();
+				return { display: repoName, branch };
+			}
+		}
+	} catch {
+		// Not in a git repo
+	}
+
+	// Final fallback: current directory (no branch - not a git repo)
+	try {
+		const dirName = getDirName(process.cwd());
+		if (dirName) {
+			return { display: dirName };
+		}
+	} catch {
+		// Shouldn't happen
+	}
+
+	return null;
+}

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

@@ -0,0 +1,310 @@
+/**
+ * File Resolution Tests
+ *
+ * Run: bun test packages/server/resolve-file.test.ts
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+	expandHomePath,
+	isAbsoluteUserPath,
+	normalizeUserPathInput,
+	resolveMarkdownFile,
+	resolveUserPath,
+} from "@plannotator/shared/resolve-file";
+
+const tempDirs: string[] = [];
+
+function createTempProject(
+  files: Record<string, string> = {},
+  baseDir = join(tmpdir(), "plannotator-resolve-file-"),
+): string {
+  const root = mkdtempSync(baseDir);
+  tempDirs.push(root);
+  for (const [relativePath, content] of Object.entries(files)) {
+    const full = join(root, relativePath);
+    mkdirSync(join(full, ".."), { recursive: true });
+    writeFileSync(full, content);
+  }
+  return root;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// --- User path normalization ---
+
+describe("normalizeUserPathInput", () => {
+	test("expands tilde paths before normalization", () => {
+		expect(normalizeUserPathInput("~/test-plan.md")).toBe(
+			join(homedir(), "test-plan.md"),
+		);
+	});
+
+	test("strips wrapping quotes", () => {
+		expect(normalizeUserPathInput('"~/test-plan.md"')).toBe(
+			join(homedir(), "test-plan.md"),
+		);
+	});
+
+  test("converts MSYS paths on Windows", () => {
+    expect(normalizeUserPathInput("/c/Users/dev/test-plan.md", "win32")).toBe(
+      "C:/Users/dev/test-plan.md",
+    );
+  });
+
+  test("converts Cygwin paths on Windows", () => {
+    expect(normalizeUserPathInput("/cygdrive/c/Users/dev/test-plan.md", "win32")).toBe(
+      "C:/Users/dev/test-plan.md",
+    );
+  });
+
+  test("leaves non-Windows paths unchanged", () => {
+    expect(normalizeUserPathInput("/Users/dev/test-plan.md", "darwin")).toBe(
+      "/Users/dev/test-plan.md",
+    );
+  });
+});
+
+describe("expandHomePath", () => {
+	test("expands bare home alias", () => {
+		expect(expandHomePath("~", "/tmp/home")).toBe("/tmp/home");
+	});
+
+	test("expands home-relative paths", () => {
+		expect(expandHomePath("~/docs/plan.md", "/tmp/home")).toBe(
+			join("/tmp/home", "docs/plan.md"),
+		);
+	});
+
+	test("does not expand tilde usernames", () => {
+		expect(expandHomePath("~alice/docs/plan.md", "/tmp/home")).toBe(
+			"~alice/docs/plan.md",
+		);
+	});
+});
+
+describe("isAbsoluteUserPath", () => {
+  test("detects Windows drive letter paths", () => {
+    expect(isAbsoluteUserPath("C:\\Users\\dev\\test-plan.md", "win32")).toBe(true);
+    expect(isAbsoluteUserPath("C:/Users/dev/test-plan.md", "win32")).toBe(true);
+  });
+
+  test("detects converted MSYS paths as absolute on Windows", () => {
+    expect(isAbsoluteUserPath("/c/Users/dev/test-plan.md", "win32")).toBe(true);
+  });
+});
+
+describe("resolveUserPath", () => {
+	test("resolves relative paths against a base directory", () => {
+		expect(resolveUserPath("docs/plan.md", "/tmp/project")).toBe(
+			resolve("/tmp/project", "docs/plan.md"),
+		);
+	});
+
+	test("resolves quoted tilde paths", () => {
+		expect(resolveUserPath('"~/docs/plan.md"')).toBe(
+			resolve(homedir(), "docs/plan.md"),
+		);
+	});
+
+	test("returns empty string for whitespace-only input", () => {
+		expect(resolveUserPath("   ", "/tmp/project")).toBe("");
+		expect(resolveUserPath("", "/tmp/project")).toBe("");
+	});
+});
+
+// --- Core resolution strategies ---
+
+describe("resolveMarkdownFile", () => {
+  // Strategy 1: Absolute paths
+
+  test("resolves absolute path to existing file", async () => {
+    const root = createTempProject({ "plan.md": "# Plan" });
+    const absPath = resolve(root, "plan.md");
+    const result = resolveMarkdownFile(absPath, root);
+    expect(result).toEqual({ kind: "found", path: absPath });
+  });
+
+	test("resolves tilde-prefixed absolute paths", async () => {
+		const homeRoot = createTempProject({}, join(homedir(), ".plannotator-resolve-file-"));
+		const absPath = resolve(homeRoot, "plan.md");
+		writeFileSync(absPath, "# Plan");
+		const relativeToHome = absPath.slice(homedir().length + 1).replace(/\\/g, "/");
+		const result = resolveMarkdownFile(`~/${relativeToHome}`, "/unused");
+		expect(result).toEqual({ kind: "found", path: absPath });
+	});
+
+  test("returns not_found for absolute path that doesn't exist", async () => {
+    const root = createTempProject();
+    const result = resolveMarkdownFile("/nonexistent/path.md", root);
+    expect(result.kind).toBe("not_found");
+  });
+
+  // Strategy 2: Exact relative paths
+
+  test("resolves exact relative path", async () => {
+    const root = createTempProject({ "docs/guide.md": "# Guide" });
+    const result = resolveMarkdownFile("docs/guide.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "docs/guide.md"),
+    });
+  });
+
+  test("resolves bare filename in root", async () => {
+    const root = createTempProject({ "README.md": "# Hello" });
+    const result = resolveMarkdownFile("README.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "README.md"),
+    });
+  });
+
+  test("resolves @ filename via fallback when @ file does not exist", async () => {
+    const root = createTempProject({ "README.md": "# Hello" });
+    const result = resolveMarkdownFile("@README.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "README.md"),
+    });
+  });
+
+  test("prioritizes real @ filename before fallback", async () => {
+    const root = createTempProject({ "@README.md": "# At" });
+    const result = resolveMarkdownFile("@README.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "@README.md"),
+    });
+  });
+
+  test("resolves quoted @ filename", async () => {
+    const root = createTempProject({ "README.md": "# Hello" });
+    const result = resolveMarkdownFile('"@README.md"', root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "README.md"),
+    });
+  });
+
+  test("resolves relative paths with Windows separators", async () => {
+    const root = createTempProject({ "docs/test-plan.md": "# Test plan\n" });
+    const result = resolveMarkdownFile("docs\\test-plan.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "docs/test-plan.md"),
+    });
+  });
+
+  // Strategy 3: Case-insensitive search
+
+  test("finds bare filenames case-insensitively", async () => {
+    const root = createTempProject({ "notes/Architecture.MD": "# Architecture\n" });
+    const result = resolveMarkdownFile("architecture.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "notes/Architecture.MD"),
+    });
+  });
+
+  test("finds relative paths case-insensitively", async () => {
+    const root = createTempProject({ "Docs/Specs/Design.MDX": "# Design\n" });
+    const result = resolveMarkdownFile("docs/specs/design.mdx", root);
+    expect(result.kind).toBe("found");
+    if (result.kind === "found") {
+      expect(await Bun.file(result.path).text()).toBe("# Design\n");
+    }
+  });
+
+  test("returns ambiguous when bare filename matches multiple files", async () => {
+    const root = createTempProject({
+      "docs/plan.md": "# Plan 1",
+      "api/plan.md": "# Plan 2",
+    });
+    const result = resolveMarkdownFile("plan.md", root);
+    expect(result.kind).toBe("ambiguous");
+    if (result.kind === "ambiguous") {
+      expect(result.matches).toHaveLength(2);
+    }
+  });
+
+  test("returns ambiguous in @ fallback when target exists multiple times", async () => {
+    const root = createTempProject({
+      "docs/plan.md": "# Plan 1",
+      "api/plan.md": "# Plan 2",
+    });
+    const result = resolveMarkdownFile("@plan.md", root);
+    expect(result.kind).toBe("ambiguous");
+    if (result.kind === "ambiguous") {
+      expect(result.input).toBe("@plan.md");
+      expect(result.matches).toHaveLength(2);
+    }
+  });
+
+  // Ignored directories
+
+  test("skips node_modules", async () => {
+    const root = createTempProject({
+      "node_modules/pkg/README.md": "# Pkg",
+    });
+    const result = resolveMarkdownFile("readme.md", root);
+    expect(result.kind).toBe("not_found");
+  });
+
+  test("skips .git directory", async () => {
+    const root = createTempProject({
+      ".git/hooks/pre-commit.md": "# hook",
+    });
+    const result = resolveMarkdownFile("pre-commit.md", root);
+    expect(result.kind).toBe("not_found");
+  });
+
+  // Extension filtering
+
+  test("rejects non-markdown files", async () => {
+    const root = createTempProject({ "script.ts": "export {}" });
+    const result = resolveMarkdownFile("script.ts", root);
+    expect(result.kind).toBe("not_found");
+  });
+
+  test("accepts .mdx files", async () => {
+    const root = createTempProject({ "page.mdx": "# Page" });
+    const result = resolveMarkdownFile("page.mdx", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "page.mdx"),
+    });
+  });
+
+  // Edge cases
+
+  test("returns not_found for nonexistent file", async () => {
+    const root = createTempProject();
+    const result = resolveMarkdownFile("nope.md", root);
+    expect(result.kind).toBe("not_found");
+  });
+
+  test("returns not_found for @ path that cannot be resolved", async () => {
+    const root = createTempProject();
+    const result = resolveMarkdownFile("@nope.md", root);
+    expect(result).toEqual({ kind: "not_found", input: "@nope.md" });
+  });
+
+  test("handles deeply nested files", async () => {
+    const root = createTempProject({
+      "a/b/c/d/deep.md": "# Deep",
+    });
+    const result = resolveMarkdownFile("deep.md", root);
+    expect(result).toEqual({
+      kind: "found",
+      path: resolve(root, "a/b/c/d/deep.md"),
+    });
+  });
+});