@ilya-lesikov/pi-pi 0.1.0

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

@@ -0,0 +1,172 @@
+/**
+ * Bear Integration Tests
+ *
+ * Run: bun test packages/server/integrations.test.ts
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  extractTitle,
+  extractTags,
+  stripH1,
+  buildHashtags,
+  buildBearContent,
+} from "./integrations";
+
+describe("extractTitle", () => {
+  test("extracts plain H1", () => {
+    expect(extractTitle("# My Plan\n\nContent")).toBe("My Plan");
+  });
+
+  test("strips Implementation Plan: prefix", () => {
+    expect(extractTitle("# Implementation Plan: Auth Flow\n\nContent")).toBe("Auth Flow");
+  });
+
+  test("strips Plan: prefix", () => {
+    expect(extractTitle("# Plan: Database Migration\n\nContent")).toBe("Database Migration");
+  });
+
+  test("falls back to 'Plan' when no H1", () => {
+    expect(extractTitle("No heading here")).toBe("Plan");
+  });
+
+  test("truncates to 50 chars", () => {
+    const long = "A".repeat(60);
+    expect(extractTitle(`# ${long}`).length).toBe(50);
+  });
+
+  test("removes special characters", () => {
+    expect(extractTitle("# Fix [bug] #123")).toBe("Fix bug 123");
+  });
+});
+
+describe("stripH1", () => {
+  test("strips first H1 line", () => {
+    expect(stripH1("# My Plan\n\n## Section\nContent")).toBe("## Section\nContent");
+  });
+
+  test("strips H1 with any wording", () => {
+    expect(stripH1("# Whatever Title Here\nBody")).toBe("Body");
+  });
+
+  test("only strips first H1, not subsequent ones", () => {
+    const input = "# First\n\n# Second\nBody";
+    expect(stripH1(input)).toBe("# Second\nBody");
+  });
+
+  test("handles plan with no H1", () => {
+    expect(stripH1("Just text\nMore text")).toBe("Just text\nMore text");
+  });
+
+  test("does not strip ## H2 headings", () => {
+    expect(stripH1("## Not H1\nBody")).toBe("## Not H1\nBody");
+  });
+});
+
+describe("buildHashtags", () => {
+  test("uses custom tags when provided", () => {
+    expect(buildHashtags("plan, work", ["plannotator"])).toBe("#plan #work");
+  });
+
+  test("falls back to auto tags when custom is empty", () => {
+    expect(buildHashtags("", ["plannotator", "myproject"])).toBe("#plannotator #myproject");
+  });
+
+  test("falls back to auto tags when custom is undefined", () => {
+    expect(buildHashtags(undefined, ["plannotator"])).toBe("#plannotator");
+  });
+
+  test("filters empty tags from trailing comma", () => {
+    expect(buildHashtags("plan, work,", ["plannotator"])).toBe("#plan #work");
+  });
+
+  test("handles whitespace-only custom tags as empty", () => {
+    expect(buildHashtags("   ", ["auto"])).toBe("#auto");
+  });
+
+  test("preserves slashes in nested Bear tags", () => {
+    expect(buildHashtags("plannotator/plans, work/code", [])).toBe("#plannotator/plans #work/code");
+  });
+
+  test("preserves slashes in auto tags with nested paths", () => {
+    expect(buildHashtags(undefined, ["plannotator/plans", "work"])).toBe("#plannotator/plans #work");
+  });
+});
+
+describe("buildBearContent", () => {
+  test("appends tags by default", () => {
+    const result = buildBearContent("Body text", "#plan #work", "append");
+    expect(result).toBe("Body text\n\n#plan #work");
+  });
+
+  test("prepends tags when configured", () => {
+    const result = buildBearContent("Body text", "#plan #work", "prepend");
+    expect(result).toBe("#plan #work\n\nBody text");
+  });
+});
+
+describe("full Bear content pipeline", () => {
+  const plan = "# Add user authentication flow\n\n## Context\nSome content here";
+
+  test("no double title — H1 stripped from body", () => {
+    const body = stripH1(plan);
+    expect(body).not.toContain("# Add user");
+    expect(body).toStartWith("## Context");
+  });
+
+  test("custom tags prepended after title removal", () => {
+    const body = stripH1(plan);
+    const hashtags = buildHashtags("plan, work", []);
+    const content = buildBearContent(body, hashtags, "prepend");
+    expect(content).toStartWith("#plan #work");
+    expect(content).toContain("## Context");
+    expect(content).not.toContain("# Add user");
+  });
+
+  test("auto tags appended when no custom tags", () => {
+    const body = stripH1(plan);
+    const hashtags = buildHashtags("", ["plannotator", "dev"]);
+    const content = buildBearContent(body, hashtags, "append");
+    expect(content).toEndWith("#plannotator #dev");
+    expect(content).toStartWith("## Context");
+  });
+});
+
+describe("extractTags", () => {
+  test("always includes plannotator tag", async () => {
+    const tags = await extractTags("# Simple Plan\n\nContent");
+    expect(tags).toContain("plannotator");
+  });
+
+  test("extracts words from title", async () => {
+    const tags = await extractTags("# Authentication Service Refactor\n\nContent");
+    expect(tags).toContain("authentication");
+    expect(tags).toContain("service");
+    expect(tags).toContain("refactor");
+  });
+
+  test("filters stop words from title", async () => {
+    const tags = await extractTags("# Implementation Plan for the System\n\nContent");
+    expect(tags).not.toContain("implementation");
+    expect(tags).not.toContain("plan");
+    expect(tags).not.toContain("the");
+    expect(tags).not.toContain("for");
+  });
+
+  test("extracts code fence languages", async () => {
+    const tags = await extractTags("# Plan\n\n```typescript\ncode\n```\n\n```rust\ncode\n```");
+    expect(tags).toContain("typescript");
+    expect(tags).toContain("rust");
+  });
+
+  test("skips generic languages", async () => {
+    const tags = await extractTags("# Plan\n\n```json\n{}\n```\n\n```yaml\nfoo\n```");
+    expect(tags).not.toContain("json");
+    expect(tags).not.toContain("yaml");
+  });
+
+  test("limits to 7 tags", async () => {
+    const tags = await extractTags("# One Two Three Four\n\n```go\n```\n```python\n```\n```ruby\n```\n```swift\n```");
+    expect(tags.length).toBeLessThanOrEqual(7);
+  });
+});

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

@@ -0,0 +1,214 @@
+/**
+ * Note-taking app integrations (Obsidian, Bear)
+ */
+
+import { $ } from "bun";
+import { join } from "path";
+import { mkdirSync, existsSync, statSync } from "fs";
+import { detectProjectName } from "./project";
+
+import {
+	type ObsidianConfig,
+	type BearConfig,
+	type OctarineConfig,
+	type IntegrationResult,
+	extractTitle,
+	generateFrontmatter,
+	generateFilename,
+	generateOctarineFrontmatter,
+	stripH1,
+	buildHashtags,
+	buildBearContent,
+	detectObsidianVaults,
+} from "@plannotator/shared/integrations-common";
+import { resolveUserPath } from "@plannotator/shared/resolve-file";
+
+export type { ObsidianConfig, BearConfig, OctarineConfig, IntegrationResult };
+export { detectObsidianVaults, extractTitle, generateFrontmatter, generateFilename, generateOctarineFrontmatter, stripH1, buildHashtags, buildBearContent };
+
+/**
+ * Extract tags from markdown content using simple heuristics
+ * Includes project name detection (git repo or directory name)
+ */
+export async function extractTags(markdown: string): Promise<string[]> {
+	const tags = new Set<string>(["plannotator"]);
+
+	// Add project name tag (git repo name or directory fallback)
+	const projectName = await detectProjectName();
+	if (projectName) {
+		tags.add(projectName);
+	}
+
+	const stopWords = new Set([
+		"the",
+		"and",
+		"for",
+		"with",
+		"this",
+		"that",
+		"from",
+		"into",
+		"plan",
+		"implementation",
+		"overview",
+		"phase",
+		"step",
+		"steps",
+	]);
+
+	// Extract from first H1 title
+	const h1Match = markdown.match(
+		/^#\s+(?:Implementation\s+Plan:|Plan:)?\s*(.+)$/im,
+	);
+	if (h1Match) {
+		const titleWords = h1Match[1]
+			.toLowerCase()
+			.replace(/[^\w\s-]/g, " ")
+			.split(/\s+/)
+			.filter((word) => word.length > 2 && !stopWords.has(word));
+		titleWords.slice(0, 3).forEach((word) => tags.add(word));
+	}
+
+	// Extract code fence languages
+	const langMatches = markdown.matchAll(/```(\w+)/g);
+	const seenLangs = new Set<string>();
+	for (const [, lang] of langMatches) {
+		const normalizedLang = lang.toLowerCase();
+		if (
+			!seenLangs.has(normalizedLang) &&
+			!["json", "yaml", "yml", "text", "txt", "markdown", "md"].includes(
+				normalizedLang,
+			)
+		) {
+			seenLangs.add(normalizedLang);
+			tags.add(normalizedLang);
+		}
+	}
+
+	return Array.from(tags).slice(0, 7);
+}
+
+// --- Obsidian Integration ---
+
+/**
+ * Save plan to Obsidian vault with cross-platform path handling
+ */
+export async function saveToObsidian(
+	config: ObsidianConfig,
+): Promise<IntegrationResult> {
+	try {
+		const { vaultPath, folder, plan } = config;
+
+		if (!vaultPath?.trim()) {
+			return { success: false, error: "Vault path is required" };
+		}
+
+		const normalizedVault = resolveUserPath(vaultPath);
+
+		// Validate vault path exists and is a directory
+		if (!existsSync(normalizedVault)) {
+			return {
+				success: false,
+				error: `Vault path does not exist: ${normalizedVault}`,
+			};
+		}
+
+		const vaultStat = statSync(normalizedVault);
+		if (!vaultStat.isDirectory()) {
+			return {
+				success: false,
+				error: `Vault path is not a directory: ${normalizedVault}`,
+			};
+		}
+
+		// Build target folder path
+		const folderName = folder.trim() || "plannotator";
+		const targetFolder = join(normalizedVault, folderName);
+
+		// Create folder if it doesn't exist (guard for Bun mkdirSync regression)
+		if (!existsSync(targetFolder)) {
+			mkdirSync(targetFolder, { recursive: true });
+		}
+
+		// Generate filename and full path
+		const filename = generateFilename(
+			plan,
+			config.filenameFormat,
+			config.filenameSeparator,
+		);
+		const filePath = join(targetFolder, filename);
+
+		// Generate content with frontmatter and backlink
+		const tags = await extractTags(plan);
+		const frontmatter = generateFrontmatter(tags);
+		const content = `${frontmatter}\n\n[[Plannotator Plans]]\n\n${plan}`;
+
+		// Write file
+		await Bun.write(filePath, content);
+
+		return { success: true, path: filePath };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Unknown error";
+		return { success: false, error: message };
+	}
+}
+
+/**
+ * Save plan to Bear using x-callback-url
+ */
+export async function saveToBear(
+	config: BearConfig,
+): Promise<IntegrationResult> {
+	try {
+		const { plan, customTags, tagPosition = "append" } = config;
+
+		const title = extractTitle(plan);
+		const body = stripH1(plan);
+
+		const tags = customTags?.trim() ? undefined : await extractTags(plan);
+		const hashtags = buildHashtags(customTags, tags ?? []);
+
+		const content = buildBearContent(body, hashtags, tagPosition);
+
+		const url = `bear://x-callback-url/create?title=${encodeURIComponent(title)}&text=${encodeURIComponent(content)}&open_note=no`;
+
+		await $`open ${url}`.quiet();
+
+		return { success: true };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Unknown error";
+		return { success: false, error: message };
+	}
+}
+
+/**
+ * Save plan to Octarine using octarine:// URI scheme
+ */
+export async function saveToOctarine(
+	config: OctarineConfig,
+): Promise<IntegrationResult> {
+	try {
+		const { plan } = config;
+		const workspace = config.workspace.trim();
+		if (!workspace) return { success: false, error: "Workspace is required" };
+		const folder = config.folder.trim() || "plannotator";
+
+		const filename = generateFilename(plan);
+		// Strip .md — Octarine auto-adds it
+		const basename = filename.replace(/\.md$/, "");
+		const path = folder ? `${folder}/${basename}` : basename;
+
+		const tags = await extractTags(plan);
+		const frontmatter = generateOctarineFrontmatter(tags);
+		const content = `${frontmatter}\n\n${plan}`;
+
+		const url = `octarine://create?path=${encodeURIComponent(path)}&content=${encodeURIComponent(content)}&workspace=${encodeURIComponent(workspace)}&fresh=true&openAfter=false`;
+
+		await $`open ${url}`.quiet();
+
+		return { success: true, path };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Unknown error";
+		return { success: false, error: message };
+	}
+}

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

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getJjDiffArgs,
+  jjLineBaseRevset,
+  selectDefaultJjCompareTarget,
+} from "./jj";
+
+describe("jj diff args", () => {
+  test("builds git-format diff args for each jj mode", () => {
+    expect(getJjDiffArgs("jj-current", "trunk()")).toEqual({
+      args: ["diff", "--git", "-r", "@"],
+      label: "Current change",
+    });
+
+    expect(getJjDiffArgs("jj-last", "trunk()")).toEqual({
+      args: ["diff", "--git", "-r", "@-"],
+      label: "Last change",
+    });
+
+    expect(getJjDiffArgs("jj-line", "trunk()")).toEqual({
+      args: ["diff", "--git", "--from", "heads(::@ & ::(trunk()))", "--to", "@"],
+      label: "Line of work vs trunk()",
+    });
+
+    expect(getJjDiffArgs("jj-all", "trunk()")).toEqual({
+      args: ["diff", "--git", "--from", "root()", "--to", "@"],
+      label: "All files",
+    });
+  });
+
+  test("preserves hide-whitespace in every jj diff mode", () => {
+    expect(getJjDiffArgs("jj-current", "trunk()", { hideWhitespace: true })?.args)
+      .toEqual(["diff", "--git", "-w", "-r", "@"]);
+    expect(getJjDiffArgs("jj-last", "trunk()", { hideWhitespace: true })?.args)
+      .toEqual(["diff", "--git", "-w", "-r", "@-"]);
+    expect(getJjDiffArgs("jj-line", "trunk()", { hideWhitespace: true })?.args)
+      .toEqual(["diff", "--git", "-w", "--from", "heads(::@ & ::(trunk()))", "--to", "@"]);
+    expect(getJjDiffArgs("jj-all", "trunk()", { hideWhitespace: true })?.args)
+      .toEqual(["diff", "--git", "-w", "--from", "root()", "--to", "@"]);
+  });
+});
+
+describe("jj compare targets", () => {
+  test("resolves default target from jj trunk bookmarks", async () => {
+    await expect(selectDefaultJjCompareTarget({
+      async runJj() {
+        return { stdout: '[{"name":"main"},{"name":"main","remote":"origin"}]\n', stderr: "", exitCode: 0 };
+      },
+    })).resolves.toBe("main@origin");
+
+    await expect(selectDefaultJjCompareTarget({
+      async runJj() {
+        return { stdout: '[{"name":"main"}]\n', stderr: "", exitCode: 0 };
+      },
+    })).resolves.toBe("main");
+
+    await expect(selectDefaultJjCompareTarget({
+      async runJj() {
+        return { stdout: "[]\n", stderr: "", exitCode: 0 };
+      },
+    })).resolves.toBe("trunk()");
+  });
+
+  test("treats bookmarks and revsets correctly in line-of-work revsets", () => {
+    expect(jjLineBaseRevset("main")).toBe('heads(::@ & ::(bookmarks(exact:"main")))');
+    expect(jjLineBaseRevset("main@origin")).toBe('heads(::@ & ::(remote_bookmarks(exact:"main", exact:"origin")))');
+    expect(jjLineBaseRevset("trunk()")).toBe("heads(::@ & ::(trunk()))");
+  });
+});

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

@@ -0,0 +1,86 @@
+import {
+  type DiffResult,
+  type DiffType,
+  type GitCommandResult,
+  type GitContext,
+  type GitDiffOptions,
+} from "@plannotator/shared/review-core";
+import {
+  type ReviewJjRuntime,
+  detectJjWorkspace as detectJjWorkspaceCore,
+  getJjContext as getJjContextCore,
+  getJjFileContentsForDiff as getJjFileContentsForDiffCore,
+  runJjDiff as runJjDiffCore,
+} from "@plannotator/shared/jj-core";
+
+export {
+  JJ_TRUNK_REVSET,
+  getJjDiffArgs,
+  jjCompareTargetRevset,
+  jjLineBaseRevset,
+  parseJjBookmarkList,
+  parseJjRemoteBookmarkList,
+  parseRemoteBookmark,
+  selectDefaultJjCompareTarget,
+} from "@plannotator/shared/jj-core";
+
+async function runJj(
+  args: string[],
+  options?: { cwd?: string; timeoutMs?: number },
+): Promise<GitCommandResult> {
+  try {
+    const proc = Bun.spawn(["jj", ...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 };
+  } catch {
+    return { stdout: "", stderr: "jj not found", exitCode: 1 };
+  }
+}
+
+export const runtime: ReviewJjRuntime = {
+  runJj,
+};
+
+export function detectJjWorkspace(cwd?: string): Promise<string | null> {
+  return detectJjWorkspaceCore(runtime, cwd);
+}
+
+export function getJjContext(cwd?: string): Promise<GitContext> {
+  return getJjContextCore(runtime, cwd);
+}
+
+export function runJjDiff(
+  diffType: DiffType,
+  defaultBranch: string,
+  cwd?: string,
+  options?: GitDiffOptions,
+): Promise<DiffResult> {
+  return runJjDiffCore(runtime, diffType, defaultBranch, cwd, options);
+}
+
+export function getJjFileContentsForDiff(
+  diffType: DiffType,
+  defaultBranch: string,
+  filePath: string,
+  oldPath?: string,
+  cwd?: string,
+): Promise<{ oldContent: string | null; newContent: string | null }> {
+  return getJjFileContentsForDiffCore(runtime, diffType, defaultBranch, filePath, oldPath, cwd);
+}