@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/packages/shared/integrations-common.ts

@@ -0,0 +1,243 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// --- Types ---
+
+export interface ObsidianConfig {
+	vaultPath: string;
+	folder: string;
+	plan: string;
+	filenameFormat?: string; // Custom format string, e.g. '{YYYY}-{MM}-{DD} - {title}'
+	filenameSeparator?: "space" | "dash" | "underscore"; // Replace spaces in filename
+}
+
+export interface BearConfig {
+	plan: string;
+	customTags?: string;
+	tagPosition?: "prepend" | "append";
+}
+
+export interface OctarineConfig {
+	plan: string;
+	workspace: string;
+	folder: string;
+}
+
+export interface IntegrationResult {
+	success: boolean;
+	error?: string;
+	path?: string;
+}
+
+/**
+ * Detect Obsidian vaults by reading Obsidian's config file
+ * Returns array of vault paths found on the system
+ */
+export function detectObsidianVaults(): string[] {
+	try {
+		const home = process.env.HOME || process.env.USERPROFILE || "";
+		let configPath: string;
+
+		// Platform-specific config locations
+		if (process.platform === "darwin") {
+			configPath = join(
+				home,
+				"Library/Application Support/obsidian/obsidian.json",
+			);
+		} else if (process.platform === "win32") {
+			const appData = process.env.APPDATA || join(home, "AppData/Roaming");
+			configPath = join(appData, "obsidian/obsidian.json");
+		} else {
+			// Linux
+			configPath = join(home, ".config/obsidian/obsidian.json");
+		}
+
+		if (!existsSync(configPath)) {
+			return [];
+		}
+
+		const configContent = readFileSync(configPath, "utf-8");
+		const config = JSON.parse(configContent);
+
+		if (!config.vaults || typeof config.vaults !== "object") {
+			return [];
+		}
+
+		// Extract vault paths, filter to ones that exist
+		const vaults: string[] = [];
+		for (const vaultId of Object.keys(config.vaults)) {
+			const vault = config.vaults[vaultId];
+			if (vault.path && existsSync(vault.path)) {
+				vaults.push(vault.path);
+			}
+		}
+
+		return vaults;
+	} catch {
+		return [];
+	}
+}
+
+// --- Frontmatter and Filename Generation ---
+
+/**
+ * Generate frontmatter for the note
+ */
+export function generateFrontmatter(tags: string[]): string {
+	const now = new Date().toISOString();
+	const tagList = tags.map((t) => t.toLowerCase()).join(", ");
+	return `---
+created: ${now}
+source: plannotator
+tags: [${tagList}]
+---`;
+}
+
+/**
+ * Extract title from markdown (first H1 heading)
+ */
+export function extractTitle(markdown: string): string {
+	const h1Match = markdown.match(
+		/^#\s+(?:Implementation\s+Plan:|Plan:)?\s*(.+)$/im,
+	);
+	if (h1Match) {
+		// Clean up the title for use as filename
+		return h1Match[1]
+			.trim()
+			.replace(/[<>:"/\\|?*(){}\[\]#~`]/g, "") // Remove invalid/problematic filename chars
+			.replace(/\s+/g, " ") // Normalize whitespace
+			.trim() // Re-trim after stripping
+			.slice(0, 50); // Limit length
+	}
+	return "Plan";
+}
+
+/** Default filename format matching original behavior */
+export const DEFAULT_FILENAME_FORMAT =
+	"{title} - {Mon} {D}, {YYYY} {h}-{mm}{ampm}";
+
+/**
+ * Generate filename from a format string with variable substitution.
+ *
+ * Supported variables:
+ *   {title}  - Plan title from first H1 heading
+ *   {YYYY}   - 4-digit year
+ *   {MM}     - 2-digit month (01-12)
+ *   {DD}     - 2-digit day (01-31)
+ *   {Mon}    - Abbreviated month name (Jan, Feb, ...)
+ *   {D}      - Day without leading zero
+ *   {HH}     - 2-digit hour, 24h (00-23)
+ *   {h}      - Hour without leading zero, 12h
+ *   {hh}     - 2-digit hour, 12h (01-12)
+ *   {mm}     - 2-digit minutes (00-59)
+ *   {ss}     - 2-digit seconds (00-59)
+ *   {ampm}   - am/pm
+ *
+ * Default format: '{title} - {Mon} {D}, {YYYY} {h}-{mm}{ampm}'
+ * Example output: 'User Authentication - Jan 2, 2026 2-30pm.md'
+ */
+export function generateFilename(
+	markdown: string,
+	format?: string,
+	separator?: "space" | "dash" | "underscore",
+): string {
+	const title = extractTitle(markdown);
+	const now = new Date();
+
+	const months = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec",
+	];
+
+	const hour24 = now.getHours();
+	const hour12 = hour24 % 12 || 12;
+	const ampm = hour24 >= 12 ? "pm" : "am";
+
+	const vars: Record<string, string> = {
+		title,
+		YYYY: String(now.getFullYear()),
+		MM: String(now.getMonth() + 1).padStart(2, "0"),
+		DD: String(now.getDate()).padStart(2, "0"),
+		Mon: months[now.getMonth()],
+		D: String(now.getDate()),
+		HH: String(hour24).padStart(2, "0"),
+		h: String(hour12),
+		hh: String(hour12).padStart(2, "0"),
+		mm: String(now.getMinutes()).padStart(2, "0"),
+		ss: String(now.getSeconds()).padStart(2, "0"),
+		ampm,
+	};
+
+	const template = format?.trim() || DEFAULT_FILENAME_FORMAT;
+	const result = template.replace(
+		/\{(\w+)\}/g,
+		(match, key) => vars[key] ?? match,
+	);
+
+	// Sanitize: remove characters invalid in filenames
+	let sanitized = result
+		.replace(/[<>:"/\\|?*]/g, "")
+		.replace(/\s+/g, " ")
+		.trim();
+
+	// Apply separator preference (replace spaces with dash or underscore)
+	if (separator === "dash") {
+		sanitized = sanitized.replace(/ /g, "-");
+	} else if (separator === "underscore") {
+		sanitized = sanitized.replace(/ /g, "_");
+	}
+
+	return sanitized.endsWith(".md") ? sanitized : `${sanitized}.md`;
+}
+
+// --- Bear Integration ---
+
+export function stripH1(plan: string): string {
+	return plan.replace(/^#\s+.+\n?/m, "").trimStart();
+}
+
+export function buildHashtags(
+	customTags: string | undefined,
+	autoTags: string[],
+): string {
+	if (customTags?.trim()) {
+		return customTags
+			.split(",")
+			.map((t) => `#${t.trim()}`)
+			.filter((t) => t !== "#")
+			.join(" ");
+	}
+	return autoTags.map((t) => `#${t}`).join(" ");
+}
+
+export function buildBearContent(
+	body: string,
+	hashtags: string,
+	tagPosition: "prepend" | "append",
+): string {
+	return tagPosition === "prepend"
+		? `${hashtags}\n\n${body}`
+		: `${body}\n\n${hashtags}`;
+}
+
+// --- Octarine Integration ---
+
+/**
+ * Generate YAML frontmatter for an Octarine note.
+ * Uses Octarine's property format (list-style tags, Status, Author, Last Edited).
+ */
+export function generateOctarineFrontmatter(tags: string[]): string {
+	const now = new Date().toISOString().slice(0, 16); // YYYY-MM-DDTHH:MM
+	const tagLines = tags.map((t) => `  - ${t.toLowerCase()}`).join("\n");
+	return `---\ntags:\n${tagLines}\nStatus: Draft\nAuthor: plannotator\nLast Edited: ${now}\n---`;
+}

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

@@ -0,0 +1,236 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getJjDiffArgs,
+  getJjEvoLogEntries,
+  jjLineBaseRevset,
+  parseJjBookmarkList,
+  parseJjRemoteBookmarkList,
+  type ReviewJjRuntime,
+  runJjDiff,
+  selectDefaultJjCompareTarget,
+} from "./jj-core";
+
+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", "@"]);
+  });
+
+  test("drops hunk-less file chunks after hide-whitespace filtering", async () => {
+    const runtimeForPatch = (stdout: string): ReviewJjRuntime => ({
+      async runJj() {
+        return {
+          stdout,
+          stderr: "",
+          exitCode: 0,
+        };
+      },
+    });
+
+    const hunklessChunk = [
+      "diff --git a/spacey.ts b/spacey.ts",
+      "index 1111111..2222222 100644",
+      "--- a/spacey.ts",
+      "+++ b/spacey.ts",
+      "",
+    ].join("\n");
+    const realChunk = [
+      "diff --git a/real.ts b/real.ts",
+      "index 3333333..4444444 100644",
+      "--- a/real.ts",
+      "+++ b/real.ts",
+      "@@ -1 +1 @@",
+      "-old",
+      "+new",
+      "",
+    ].join("\n");
+
+    const result = await runJjDiff(runtimeForPatch(hunklessChunk + realChunk), "jj-current", "trunk()", undefined, { hideWhitespace: true });
+
+    expect(result.patch).not.toContain("spacey.ts");
+    expect(result.patch).toContain("real.ts");
+    expect(result.patch).toContain("@@ -1 +1 @@");
+
+    const emptyResult = await runJjDiff(runtimeForPatch(hunklessChunk), "jj-current", "trunk()", undefined, { hideWhitespace: true });
+    expect(emptyResult.patch).toBe("");
+  });
+});
+
+describe("jj compare targets", () => {
+  test("resolves default target from jj trunk remote bookmarks", async () => {
+    const calls: string[][] = [];
+    const runtime: ReviewJjRuntime = {
+      async runJj(args) {
+        calls.push(args);
+        return { stdout: '[{"name":"main"},{"name":"main","remote":"origin"}]\n', stderr: "", exitCode: 0 };
+      },
+    };
+
+    await expect(selectDefaultJjCompareTarget(runtime, "/repo"))
+      .resolves.toBe("main@origin");
+    expect(calls).toEqual([[
+      "log",
+      "--no-graph",
+      "-r",
+      "trunk()",
+      "-T",
+      "json(bookmarks)",
+    ]]);
+  });
+
+  test("falls back to local bookmark then trunk revset", async () => {
+    const runtimeFor = (stdout: string): ReviewJjRuntime => ({
+      async runJj() {
+        return { stdout, stderr: "", exitCode: 0 };
+      },
+    });
+
+    await expect(selectDefaultJjCompareTarget(runtimeFor('[{"name":"develop"}]\n')))
+      .resolves.toBe("develop");
+    await expect(selectDefaultJjCompareTarget(runtimeFor('[]\n')))
+      .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()))");
+  });
+});
+
+describe("jj evolog", () => {
+  test("builds evolog diff args with explicit base", () => {
+    expect(getJjDiffArgs("jj-evolog", "abc123456789")).toEqual({
+      args: ["diff", "--git", "--from", "abc123456789", "--to", "@"],
+      label: "Evolution diff from abc12345",
+    });
+  });
+
+  test("builds evolog diff args with whitespace flag", () => {
+    expect(getJjDiffArgs("jj-evolog", "abc123456789", { hideWhitespace: true })?.args)
+      .toEqual(["diff", "--git", "-w", "--from", "abc123456789", "--to", "@"]);
+  });
+
+  test("parses evolog output correctly (commit.* template fields)", async () => {
+    const runtime: ReviewJjRuntime = {
+      async runJj() {
+        return {
+          stdout: [
+            "abc123456789\tAdd login form\t2 minutes ago",
+            "def456789012\tAdd login form\t10 minutes ago",
+            "ghi789012345\tAdd login form\t1 hour ago",
+            "",
+          ].join("\n"),
+          stderr: "",
+          exitCode: 0,
+        };
+      },
+    };
+    const entries = await getJjEvoLogEntries(runtime);
+    expect(entries).toHaveLength(3);
+    expect(entries[0]).toEqual({ commitId: "abc123456789", description: "Add login form", age: "2 minutes ago" });
+    expect(entries[1]).toEqual({ commitId: "def456789012", description: "Add login form", age: "10 minutes ago" });
+    expect(entries[2]).toEqual({ commitId: "ghi789012345", description: "Add login form", age: "1 hour ago" });
+  });
+
+  test("returns empty array when evolog exits non-zero", async () => {
+    const runtime: ReviewJjRuntime = {
+      async runJj() {
+        return { stdout: "", stderr: "error: no such revision", exitCode: 1 };
+      },
+    };
+    const entries = await getJjEvoLogEntries(runtime);
+    expect(entries).toHaveLength(0);
+  });
+
+  test("defaults to second evolog entry when no base given", async () => {
+    let callCount = 0;
+    const calls: string[][] = [];
+    const runtime: ReviewJjRuntime = {
+      async runJj(args) {
+        calls.push(args);
+        callCount++;
+        if (args[0] === "evolog") {
+          return {
+            stdout: [
+              "abc123456789\tFix bug\t1 minute ago",
+              "def456789012\tFix bug\t5 minutes ago",
+              "",
+            ].join("\n"),
+            stderr: "",
+            exitCode: 0,
+          };
+        }
+        return { stdout: "diff --git a/foo.ts b/foo.ts\n", stderr: "", exitCode: 0 };
+      },
+    };
+    const result = await runJjDiff(runtime, "jj-evolog", "");
+    expect(result.label).toBe("Evolution diff from def45678");
+    // evolog call + diff call
+    expect(callCount).toBe(2);
+    const diffCall = calls.find((c) => c[0] === "diff");
+    expect(diffCall).toEqual(["diff", "--git", "--from", "def456789012", "--to", "@"]);
+  });
+
+  test("returns error when evolog has no previous entry", async () => {
+    const runtime: ReviewJjRuntime = {
+      async runJj(args) {
+        if (args[0] === "evolog") {
+          return { stdout: "abc123456789\tInitial commit\t1 minute ago\n", stderr: "", exitCode: 0 };
+        }
+        return { stdout: "", stderr: "", exitCode: 0 };
+      },
+    };
+    const result = await runJjDiff(runtime, "jj-evolog", "");
+    expect(result.error).toBe("No previous evolution found");
+    expect(result.patch).toBe("");
+  });
+});
+
+describe("jj bookmark parsing", () => {
+  test("parses escaped newline separators from jj bookmark templates", () => {
+    expect(parseJjBookmarkList('"dev"\\n"main"\\n')).toEqual(["dev", "main"]);
+  });
+
+  test("parses escaped tab and newline separators from jj remote bookmark templates", () => {
+    expect(parseJjRemoteBookmarkList('"main"\\t"git"\\n"release"\\t"origin"\\n')).toEqual([
+      "main@git",
+      "release@origin",
+    ]);
+  });
+
+  test("preserves git remote bookmarks from colocated jj repositories", () => {
+    expect(parseJjRemoteBookmarkList('"main"\t"git"\n"release"\t"origin"\n')).toEqual([
+      "main@git",
+      "release@origin",
+    ]);
+  });
+});