personal-ai 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1761 @@
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import JSON5 from "json5";
+import matter from "gray-matter";
+import chalk from "chalk";
+import ora from "ora";
+import { execFile } from "node:child_process";
+import OpenAI from "openai";
+import { minimatch } from "minimatch";
+
+//#region src/config/paths.ts
+/** Root data directory for pai */
+function getPaiHome() {
+	return process.env.PAI_HOME ?? path.join(os.homedir(), ".pai");
+}
+function getRawDir() {
+	return path.join(getPaiHome(), "raw");
+}
+function getVaultDir() {
+	return path.join(getPaiHome(), "vault");
+}
+function getSkillsDir() {
+	return path.join(getPaiHome(), "skills", "profiles");
+}
+function getConfigDir() {
+	return path.join(getPaiHome(), "config");
+}
+function getConfigPath() {
+	return path.join(getConfigDir(), "pai.json5");
+}
+function getProfilesPath() {
+	return path.join(getConfigDir(), "profiles.json5");
+}
+function getPreferencesPath() {
+	return path.join(getConfigDir(), "preferences.md");
+}
+/** Compiled user profile — the core output of pai */
+function getProfilePath() {
+	return path.join(getPaiHome(), "profile.md");
+}
+
+//#endregion
+//#region src/config/schema.ts
+const QmdConfigSchema = z.object({
+	rawCollection: z.string().default("raw"),
+	vaultCollection: z.string().default("vault")
+});
+const LlmConfigSchema = z.object({
+	apiKeyEnv: z.string().default("OPENAI_API_KEY"),
+	baseUrl: z.string().optional(),
+	cheapModel: z.string().default("gpt-4o-mini"),
+	expensiveModel: z.string().default("gpt-4o")
+});
+const ScraperConfigSchema = z.object({ timeout: z.number().default(3e4) });
+const VaultConfigSchema = z.object({
+	maxFileTokens: z.number().default(4e3),
+	warnFileTokens: z.number().default(3e3)
+});
+const PaiConfigSchema = z.object({
+	version: z.string().default("0.1"),
+	qmd: QmdConfigSchema.default(() => QmdConfigSchema.parse({})),
+	llm: LlmConfigSchema.default(() => LlmConfigSchema.parse({})),
+	scraper: ScraperConfigSchema.default(() => ScraperConfigSchema.parse({})),
+	vault: VaultConfigSchema.default(() => VaultConfigSchema.parse({}))
+}).strict();
+
+//#endregion
+//#region src/config/io.ts
+/** Load and validate pai.json5 config */
+async function loadConfig() {
+	const configPath = getConfigPath();
+	try {
+		const raw = await fs.readFile(configPath, "utf-8");
+		const parsed = JSON5.parse(raw);
+		return PaiConfigSchema.parse(parsed);
+	} catch (err) {
+		if (err.code === "ENOENT") return PaiConfigSchema.parse({});
+		throw err;
+	}
+}
+/** Load profiles.json5 */
+async function loadProfiles() {
+	const profilesPath = getProfilesPath();
+	try {
+		const raw = await fs.readFile(profilesPath, "utf-8");
+		return JSON5.parse(raw);
+	} catch (err) {
+		if (err.code === "ENOENT") return { profiles: {} };
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/utils/slug.ts
+/** Generate a URL-safe slug from a title string */
+function generateSlug(title) {
+	return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+/** Generate a timestamped filename: YYYY-MM-DDTHH-MM-{slug}.md */
+function generateRawFilename(title) {
+	return `${(/* @__PURE__ */ new Date()).toISOString().replace(/:\d{2}\.\d{3}Z$/, "").replace(/:/g, "-")}-${generateSlug(title) || "untitled"}.md`;
+}
+
+//#endregion
+//#region src/utils/frontmatter.ts
+/** Parse a markdown file with frontmatter */
+function parseFrontmatter(content) {
+	const result = matter(content);
+	return {
+		data: result.data,
+		content: result.content
+	};
+}
+/** Stringify data + content into a frontmatter markdown string */
+function stringifyFrontmatter(data, content) {
+	return matter.stringify(content, data);
+}
+/** Create a raw file with proper frontmatter */
+function createRawFile(frontmatter, title, body) {
+	return stringifyFrontmatter(frontmatter, `\n# ${title}\n\n${body}\n`);
+}
+/** Update frontmatter fields in a raw file */
+function updateRawFrontmatter(fileContent, updates) {
+	const { data, content } = parseFrontmatter(fileContent);
+	return stringifyFrontmatter({
+		...data,
+		...updates
+	}, content);
+}
+
+//#endregion
+//#region src/raw/add.ts
+/** Add plain text content to raw/local/ */
+async function addText(content, source = "local") {
+	const title = extractTitle(content);
+	const filename = generateRawFilename(title);
+	const dir = path.join(getRawDir(), "local");
+	await fs.mkdir(dir, { recursive: true });
+	const fileContent = createRawFile({
+		source,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "pending"
+	}, title, content);
+	const filePath = path.join(dir, filename);
+	await fs.writeFile(filePath, fileContent, "utf-8");
+	return filePath;
+}
+/** Add a local file's content to raw/local/ */
+async function addFile(filePath, source = "local") {
+	const content = await fs.readFile(filePath, "utf-8");
+	const basename = path.basename(filePath, path.extname(filePath));
+	const filename = generateRawFilename(basename);
+	const dir = path.join(getRawDir(), "local");
+	await fs.mkdir(dir, { recursive: true });
+	const fileContent = createRawFile({
+		source,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "pending"
+	}, basename, content);
+	const outPath = path.join(dir, filename);
+	await fs.writeFile(outPath, fileContent, "utf-8");
+	return outPath;
+}
+/** Add URL-scraped content to raw/web/ */
+async function addUrl(url, title, markdown) {
+	const filename = generateRawFilename(title);
+	const dir = path.join(getRawDir(), "web");
+	await fs.mkdir(dir, { recursive: true });
+	const fileContent = createRawFile({
+		source: "web",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		url,
+		status: "pending"
+	}, title, markdown);
+	const filePath = path.join(dir, filename);
+	await fs.writeFile(filePath, fileContent, "utf-8");
+	return filePath;
+}
+/**
+* Add or update a connector-scanned entry to raw/connector/{name}/.
+* Uses scan_id in frontmatter for dedup:
+*   - If no existing file with same scan_id → create new
+*   - If existing file with same content body → skip ("skipped")
+*   - If existing file with different content → overwrite ("updated")
+* Returns "created" | "updated" | "skipped".
+*/
+async function addConnectorEntry(connectorName, entry) {
+	const dir = path.join(getRawDir(), "connector", connectorName);
+	await fs.mkdir(dir, { recursive: true });
+	const scanId = `${connectorName}/${entry.id}`;
+	const existingPath = await findByScanId(dir, scanId);
+	const fm = {
+		source: `connector/${connectorName}`,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "pending",
+		scan_id: scanId
+	};
+	if (existingPath) {
+		const { content: oldBody } = parseFrontmatter(await fs.readFile(existingPath, "utf-8"));
+		const newBody = `\n# ${entry.title}\n\n${entry.content}\n`;
+		if (oldBody.trim() === newBody.trim()) return "skipped";
+		const fileContent = createRawFile(fm, entry.title, entry.content);
+		await fs.writeFile(existingPath, fileContent, "utf-8");
+		return "updated";
+	}
+	const filename = generateRawFilename(entry.id);
+	const fileContent = createRawFile(fm, entry.title, entry.content);
+	const filePath = path.join(dir, filename);
+	await fs.writeFile(filePath, fileContent, "utf-8");
+	return "created";
+}
+/** Find a raw file in a directory whose frontmatter scan_id matches */
+async function findByScanId(dir, scanId) {
+	try {
+		const entries = await fs.readdir(dir);
+		for (const name of entries) {
+			if (!name.endsWith(".md")) continue;
+			const filePath = path.join(dir, name);
+			const content = await fs.readFile(filePath, "utf-8");
+			if (content.includes(`scan_id: ${scanId}`) || content.includes(`scan_id: '${scanId}'`)) return filePath;
+		}
+	} catch {}
+	return null;
+}
+/** List all pending raw files (status: pending) */
+async function listPending() {
+	const rawDir = getRawDir();
+	const pending = [];
+	for (const sub of [
+		"local",
+		"web",
+		"connector"
+	]) {
+		const dir = path.join(rawDir, sub);
+		try {
+			const entries = await walkDir(dir);
+			for (const entry of entries) if (entry.endsWith(".md")) {
+				if ((await fs.readFile(entry, "utf-8")).includes("status: pending")) pending.push(entry);
+			}
+		} catch {}
+	}
+	return pending;
+}
+/** Recursively walk a directory and return file paths */
+async function walkDir(dir) {
+	const results = [];
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...await walkDir(fullPath));
+			else results.push(fullPath);
+		}
+	} catch {}
+	return results;
+}
+/** Extract a title from content (first line or first N words) */
+function extractTitle(content) {
+	const cleaned = (content.split("\n")[0]?.trim() ?? "").replace(/^#+\s*/, "");
+	if (cleaned.length > 0 && cleaned.length <= 100) return cleaned;
+	return content.split(/\s+/).slice(0, 8).join(" ").slice(0, 100) || "untitled";
+}
+
+//#endregion
+//#region src/utils/console.ts
+function info(message) {
+	console.log(chalk.blue("ℹ"), message);
+}
+function warn(message) {
+	console.warn(chalk.yellow("⚠"), message);
+}
+function spinner(text) {
+	return ora({
+		text,
+		color: "cyan"
+	}).start();
+}
+
+//#endregion
+//#region src/scraper/index.ts
+/**
+* Scrape a URL and return title + markdown content.
+* Uses fetch + defuddle for content extraction.
+* Falls back to basic HTML extraction if defuddle is unavailable.
+*/
+async function scrapeUrl(url, timeout = 3e4) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeout);
+	let html;
+	try {
+		const response = await fetch(url, {
+			signal: controller.signal,
+			headers: {
+				"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+				Accept: "text/html,application/xhtml+xml"
+			}
+		});
+		if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		html = await response.text();
+	} finally {
+		clearTimeout(timer);
+	}
+	try {
+		const defuddleMod = await import("defuddle/node");
+		const Defuddle = defuddleMod.Defuddle ?? defuddleMod.default;
+		if (Defuddle) {
+			const result = new Defuddle(html, { url }).parse();
+			return {
+				url,
+				title: result.title || extractTitleFromHtml(html),
+				markdown: result.content ? htmlToSimpleMarkdown(result.content) : extractTextFromHtml(html)
+			};
+		}
+	} catch {
+		warn("defuddle not available, using basic HTML extraction");
+	}
+	return {
+		url,
+		title: extractTitleFromHtml(html),
+		markdown: extractTextFromHtml(html)
+	};
+}
+/** Extract <title> from HTML */
+function extractTitleFromHtml(html) {
+	return html.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1]?.trim() ?? "Untitled";
+}
+/** Basic HTML to text extraction (fallback) */
+function extractTextFromHtml(html) {
+	return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim().slice(0, 1e4);
+}
+/** Convert simple HTML to markdown */
+function htmlToSimpleMarkdown(html) {
+	return html.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "# $1\n\n").replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "## $1\n\n").replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "### $1\n\n").replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, "$1\n\n").replace(/<br\s*\/?>/gi, "\n").replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, "**$1**").replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, "*$1*").replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)").replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n").replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`").replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, "```\n$1\n```\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+//#endregion
+//#region src/utils/process.ts
+/** Execute QMD CLI command and return stdout */
+async function execQmd(args) {
+	return new Promise((resolve, reject) => {
+		execFile("qmd", args, {
+			encoding: "utf-8",
+			timeout: 6e4
+		}, (err, stdout, stderr) => {
+			if (err) {
+				const msg = stderr?.trim() || err.message;
+				reject(/* @__PURE__ */ new Error(`qmd ${args[0]} failed: ${msg}`));
+			} else resolve(stdout);
+		});
+	});
+}
+/** Check if QMD is available on PATH */
+async function isQmdAvailable() {
+	try {
+		await execQmd(["status"]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/search/index.ts
+/**
+* Hybrid search via QMD.
+* - "query"   (default): BM25 + vector + expansion + reranking (~5s, best quality)
+* - "search":            BM25 keyword + rg grep fallback (~50ms, fast)
+* - "vsearch":           Vector similarity only (~2s, good for semantic)
+*
+* For "search" (fast) mode, QMD BM25 doesn't support CJK tokenization,
+* so we supplement with ripgrep to cover Chinese/Japanese/Korean.
+*/
+async function search(query, collection = "vault", n = 5, mode = "query") {
+	if (!await isQmdAvailable()) throw new Error("QMD is not installed. Install with: npm install -g https://github.com/tobi/qmd");
+	let results = parseSearchResults(await execQmd([
+		mode,
+		query,
+		"--collection",
+		collection,
+		"--json",
+		"-n",
+		String(n)
+	]));
+	if (mode === "search" && results.length === 0 && hasCjk(query)) results = await grepFallback(query, collection, n);
+	return results;
+}
+/** Parse QMD JSON search output into SearchResult[] */
+function parseSearchResults(stdout) {
+	try {
+		const parsed = JSON.parse(stdout);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.map((item) => ({
+			file: item.file ?? "",
+			title: item.title ?? void 0,
+			snippet: item.snippet ?? item.content?.slice(0, 200) ?? "",
+			score: item.score
+		}));
+	} catch {
+		return [];
+	}
+}
+/** Check if a string contains CJK characters */
+function hasCjk(text) {
+	return /[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(text);
+}
+/**
+* grep fallback for CJK text that BM25 can't tokenize.
+* Runs: grep -rl "query" <dir> --include="*.md"
+* Then reads matched files and extracts context.
+*/
+async function grepFallback(query, collection, n) {
+	const baseDir = collection === "raw" ? getRawDir() : getVaultDir();
+	const stdout = await new Promise((resolve) => {
+		execFile("grep", [
+			"-rl",
+			"--include=*.md",
+			query,
+			baseDir
+		], {
+			encoding: "utf-8",
+			timeout: 5e3
+		}, (_err, out) => {
+			resolve(out ?? "");
+		});
+	});
+	if (!stdout.trim()) return [];
+	const files = stdout.trim().split("\n").slice(0, n);
+	const results = [];
+	for (const filePath of files) {
+		if (!filePath) continue;
+		const snippet = (await new Promise((resolve) => {
+			execFile("grep", [
+				"-m1",
+				"-C1",
+				query,
+				filePath
+			], {
+				encoding: "utf-8",
+				timeout: 2e3
+			}, (_err, out) => resolve(out ?? ""));
+		})).replace(/\n/g, " ").trim().slice(0, 160);
+		const relative = path.relative(baseDir, filePath);
+		const titleLine = await new Promise((resolve) => {
+			execFile("grep", [
+				"-m1",
+				"^# ",
+				filePath
+			], {
+				encoding: "utf-8",
+				timeout: 1e3
+			}, (_err, out) => resolve(out?.replace(/^#\s+/, "").trim() ?? ""));
+		});
+		results.push({
+			file: `qmd://${collection}/${relative}`,
+			title: titleLine || path.basename(filePath, ".md"),
+			snippet,
+			score: 1
+		});
+	}
+	return results;
+}
+/** Update QMD index: runs `qmd update` + `qmd embed` */
+async function updateIndex() {
+	await execQmd(["update"]);
+	await execQmd(["embed"]);
+}
+
+//#endregion
+//#region src/llm/client.ts
+let cachedConfig = null;
+let cachedPreferences = null;
+async function getConfig() {
+	if (!cachedConfig) cachedConfig = await loadConfig();
+	return cachedConfig;
+}
+/** Load user preferences.md (cached per process) */
+async function getPreferences() {
+	if (cachedPreferences !== null) return cachedPreferences;
+	try {
+		cachedPreferences = await fs.readFile(getPreferencesPath(), "utf-8");
+	} catch {
+		cachedPreferences = "";
+	}
+	return cachedPreferences;
+}
+/** Create an OpenAI-compatible client from config */
+async function createLlmClient() {
+	const config = await getConfig();
+	const apiKey = process.env[config.llm.apiKeyEnv];
+	if (!apiKey) throw new Error(`Missing API key: set ${config.llm.apiKeyEnv} environment variable`);
+	return new OpenAI({
+		apiKey,
+		baseURL: config.llm.baseUrl || void 0
+	});
+}
+/**
+* Single LLM call with system + user messages.
+* Automatically prepends user preferences to the system prompt.
+* Retries once on failure.
+*/
+async function llmCall(prompt, system, model) {
+	const config = await getConfig();
+	const client = await createLlmClient();
+	const modelName = model ?? config.llm.cheapModel;
+	const prefs = await getPreferences();
+	const fullSystem = prefs ? `${system}\n\n---USER PREFERENCES (always respect these)---\n${prefs}` : system;
+	for (let attempt = 0; attempt < 2; attempt++) try {
+		return (await client.chat.completions.create({
+			model: modelName,
+			messages: [{
+				role: "system",
+				content: fullSystem
+			}, {
+				role: "user",
+				content: prompt
+			}],
+			temperature: .3
+		})).choices[0]?.message?.content ?? "";
+	} catch (err) {
+		if (attempt === 0) {
+			await new Promise((r) => setTimeout(r, 1e3));
+			continue;
+		}
+		throw err;
+	}
+	return "";
+}
+
+//#endregion
+//#region src/prompts/triage.ts
+/** Build system prompt for the triage step */
+function triageSystemPrompt() {
+	return `You are a personal knowledge management assistant.
+Your job is to evaluate raw input and extract ALL distinct pieces of personal context worth preserving.
+
+CRITICAL: One raw input often contains MULTIPLE types of data. You MUST split them into separate entries routed to different vault files.
+
+Two kinds of valuable content:
+
+1) EXPERIENTIAL: concrete lessons, preferences, tips, or experiences.
+2) SYSTEM CONTEXT: data from system/connector scans — identity, environment, habits, preferences.
+
+Routing targets:
+- vault/context/identity.md — name, email, role, languages, locale, timezone
+- vault/context/active-projects.md — repos, cloud infra, SSH hosts
+- vault/preferences/tools.md — tech stack, IDEs, runtimes, package managers
+- vault/preferences/workflow.md — shell habits, git config, aliases, dev workflow
+- vault/life/interests.md — interests, domains of focus, bookmarks, browsing patterns
+- vault/life/lifestyle.md — calendar, apps, music, media, daily routines
+- vault/coding/*.md — coding lessons (use existing or suggest new)
+- vault/work/*.md — work-related lessons and context
+
+Do NOT mark as valuable: generic news, ads, or content with no personal signal.
+
+Respond ONLY with valid JSON (no markdown fences):
+{
+  "valuable": true/false,
+  "entries": [
+    { "targetFile": "vault/context/identity.md", "extract": "name, email, role, languages" },
+    { "targetFile": "vault/preferences/tools.md", "extract": "IDE, runtimes, package managers" }
+  ],
+  "reason": "brief explanation"
+}
+
+Rules:
+- entries array can have 1-6 items — split aggressively by topic
+- Each entry.extract is a SHORT directive telling the distill step WHAT to pull for that target
+- If not valuable, entries should be empty []
+- Use existing vault files from the list when available`;
+}
+/** Build user prompt for triage */
+function triageUserPrompt(rawContent, vaultFiles) {
+	return `Evaluate this raw input and decide if it's worth distilling:
+
+---RAW CONTENT---
+${rawContent}
+---END RAW CONTENT---
+${vaultFiles.length > 0 ? `\nExisting vault files:\n${vaultFiles.map((f) => `- ${f}`).join("\n")}` : "\nNo existing vault files yet."}
+
+Route to context/, preferences/, life/, coding/, or work/ as appropriate. Respond with JSON only.`;
+}
+
+//#endregion
+//#region src/distill/triage.ts
+/** Run triage on a raw file to determine if it's worth distilling */
+async function triageRawFile(rawContent, vaultFiles) {
+	const system = triageSystemPrompt();
+	const response = await llmCall(triageUserPrompt(rawContent, vaultFiles), system);
+	try {
+		const cleaned = response.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+		const raw = JSON.parse(cleaned);
+		let entries = [];
+		if (Array.isArray(raw.entries)) entries = raw.entries.filter((e) => typeof e.targetFile === "string" && typeof e.extract === "string").map((e) => ({
+			targetFile: e.targetFile,
+			extract: e.extract
+		}));
+		if (entries.length === 0 && typeof raw.targetFile === "string" && raw.targetFile) entries = [{
+			targetFile: raw.targetFile,
+			extract: "all relevant content"
+		}];
+		return {
+			valuable: Boolean(raw.valuable),
+			entries,
+			reason: raw.reason ?? ""
+		};
+	} catch {
+		return {
+			valuable: false,
+			entries: [],
+			reason: `Failed to parse triage response: ${response.slice(0, 100)}`
+		};
+	}
+}
+
+//#endregion
+//#region src/prompts/distill.ts
+/** Build system prompt for the distill & merge step */
+function distillSystemPrompt() {
+	return `You are a personal knowledge distillation assistant.
+Your job is to extract and merge valuable personal context from raw input into a vault document.
+
+Two modes:
+
+A) EXPERIENTIAL content (lessons, tips, experiences):
+- Extract ONLY conclusions and actionable knowledge — never copy raw text verbatim
+- If a similar experience already exists, increment its verification count
+- Each bullet: (source, date | ref: raw/path)
+
+B) SYSTEM CONTEXT content (identity, environment, habits, bookmarks, etc.):
+- Do NOT dump raw lists verbatim (e.g. every package path or every bookmark folder)
+- Synthesize into a compact, HIGH-DENSITY profile:
+  - Identity: name, role, languages, locale, timezone — one line each
+  - Tools: summarize tech stack concisely (e.g. "Full-stack: Node/Python/Go/Rust, IDEs: Cursor+Android Studio")
+  - Workflow: summarize habits (e.g. "Heavy git user (4762 commands), frequent claude CLI, command-line focused")
+  - Life: summarize calendar themes, main apps, browsing focus — with concrete data
+  - Interests: summarize bookmark categories AND top domains as interest tags (e.g. "AI/LLM, GIS, iOS, Python, Web3")
+  - Projects: summarize active areas with names (e.g. "PINAI (PIN-APP-IOS, PIN-AGENT-WEB), consulting, agent-market")
+
+CRITICAL RULES:
+- NEVER write "未提供", "未指定", "Not specified", "Unknown" — if data is not in the raw input, simply OMIT that field
+- Only include sections and fields that have ACTUAL data from the raw input
+- Do NOT create empty placeholder sections. If an H2 section would be empty, skip it entirely
+- Each vault file handles ONE topic — only include relevant data from the raw input
+- Keep information density HIGH: pack maximum facts per line
+- Maintain H2 (##) section structure
+- Keep each H2 section between 200-800 tokens
+- Preserve all existing vault content — only add or update, never remove
+- Output the COMPLETE updated vault file content (not just the changes)
+- End each new bullet with source ref: (source, date | ref: raw/path/to/file.md)`;
+}
+/** Build user prompt for distill & merge */
+function distillUserPrompt(rawContent, rawFilePath, existingVaultContent, extractDirective) {
+	return `Distill the following raw input and merge into the vault document:
+
+---RAW CONTENT (from: ${rawFilePath})---
+${rawContent}
+---END RAW CONTENT---
+
+${existingVaultContent ? `---EXISTING VAULT DOCUMENT---\n${existingVaultContent}\n---END VAULT DOCUMENT---` : "This is a NEW vault document. Create it with appropriate H1 title and H2 sections."}
+${extractDirective ? `\nFOCUS: Only extract data related to: ${extractDirective}. Ignore unrelated content in the raw input.` : ""}
+Output the COMPLETE updated vault file content.
+Rules: synthesize into high-density profile. NEVER write "未提供"/"Not specified"/"Unknown" — omit fields with no data instead. Only include sections with actual data.`;
+}
+
+//#endregion
+//#region src/distill/merge.ts
+/**
+* Distill raw content and merge into a vault file.
+* Creates the vault file if it doesn't exist.
+* @param extractDirective - Optional hint telling LLM what to extract from raw content for this target
+*/
+async function distillAndMerge(rawContent, rawFilePath, targetFile, extractDirective) {
+	const vaultDir = getVaultDir();
+	const relativePath = targetFile.replace(/^vault\//, "");
+	const fullPath = path.join(vaultDir, relativePath);
+	let existingContent = null;
+	try {
+		existingContent = await fs.readFile(fullPath, "utf-8");
+	} catch {}
+	const system = distillSystemPrompt();
+	const updatedContent = await llmCall(distillUserPrompt(rawContent, rawFilePath, existingContent, extractDirective), system);
+	await fs.mkdir(path.dirname(fullPath), { recursive: true });
+	await fs.writeFile(fullPath, updatedContent.trim() + "\n", "utf-8");
+	return fullPath;
+}
+
+//#endregion
+//#region src/distill/index.ts
+/** List all existing vault files (relative paths like "coding/python.md") */
+async function listVaultFiles() {
+	const vaultDir = getVaultDir();
+	const files = [];
+	async function walk(dir) {
+		try {
+			const entries = await fs.readdir(dir, { withFileTypes: true });
+			for (const entry of entries) {
+				const fullPath = path.join(dir, entry.name);
+				if (entry.isDirectory()) await walk(fullPath);
+				else if (entry.name.endsWith(".md")) files.push(path.relative(vaultDir, fullPath));
+			}
+		} catch {}
+	}
+	await walk(vaultDir);
+	return files;
+}
+/** Run the full distill pipeline on all pending raw files */
+async function distillPipeline(options = {}) {
+	const result = {
+		processed: 0,
+		valuable: 0,
+		discarded: 0,
+		errors: []
+	};
+	let pendingFiles;
+	if (options.singleFile) pendingFiles = [options.singleFile];
+	else pendingFiles = await listPending();
+	if (pendingFiles.length === 0) {
+		info("No pending raw files to process.");
+		return result;
+	}
+	info(`Found ${pendingFiles.length} pending file(s) to process.`);
+	const vaultFilesList = (await listVaultFiles()).map((f) => `vault/${f}`);
+	for (const filePath of pendingFiles) {
+		const spin = spinner(`Processing ${path.basename(filePath)}...`);
+		try {
+			const rawFileContent = await fs.readFile(filePath, "utf-8");
+			const { content } = parseFrontmatter(rawFileContent);
+			const triage = await triageRawFile(content, vaultFilesList);
+			result.processed++;
+			if (!triage.valuable || triage.entries.length === 0) {
+				spin.succeed(`Discarded: ${path.basename(filePath)} — ${triage.reason}`);
+				result.discarded++;
+				if (!options.dryRun) {
+					const updated = updateRawFrontmatter(rawFileContent, { status: "discarded" });
+					await fs.writeFile(filePath, updated, "utf-8");
+				}
+				continue;
+			}
+			const targets = triage.entries.map((e) => e.targetFile);
+			if (options.dryRun) {
+				spin.succeed(`[DRY RUN] Would distill ${path.basename(filePath)} → ${targets.join(", ")}`);
+				result.valuable++;
+				continue;
+			}
+			const mergedPaths = [];
+			for (const entry of triage.entries) {
+				const targetFile = entry.targetFile || "vault/context/misc.md";
+				const vaultPath = await distillAndMerge(content, filePath, targetFile, entry.extract);
+				mergedPaths.push(vaultPath);
+				if (!vaultFilesList.includes(targetFile)) vaultFilesList.push(targetFile);
+			}
+			result.valuable++;
+			const updated = updateRawFrontmatter(rawFileContent, {
+				status: "processed",
+				distilled_to: mergedPaths.map((p) => path.relative(path.dirname(filePath).replace(/\/raw\/.*/, "/raw"), p)).join(", ")
+			});
+			await fs.writeFile(filePath, updated, "utf-8");
+			spin.succeed(`Distilled ${path.basename(filePath)} → ${targets.join(", ")} (${triage.entries.length} entries)`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			spin.fail(`Error processing ${path.basename(filePath)}: ${msg}`);
+			result.errors.push(`${filePath}: ${msg}`);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/prompts/generate.ts
+/** Build system prompt for SKILL.md generation */
+function generateSystemPrompt() {
+	return `You are generating a concise SKILL.md personal context file for an AI agent.
+This file helps the agent understand the user's background, preferences, and experiences.
+
+Rules:
+- Be extremely concise — every line must carry HIGH information density
+- Pack maximum concrete facts per bullet (names, numbers, specific tools)
+- Prioritize experiences with higher verification counts when present
+- Use bullet points for each piece of context
+- Follow the exact section structure provided
+- Do NOT include generic advice — only user-specific context
+- NEVER write filler like "未提供", "Not specified" or vague statements
+- Write in the same language as the source content
+
+When vault content includes identity/tools/workflow/interests data:
+- "Who I Am": real name, email, languages with specifics, locale, timezone, tech identity
+- "Preferences": specific tools by name, workflow patterns with data (e.g. "git: 4762 commands"), communication style
+- "Hard-won Lessons": only include if genuine lessons exist; otherwise omit or make it 1-2 lines
+- "Current Work": specific project names, focus areas, active repos — be concrete`;
+}
+/** Build user prompt for SKILL.md generation */
+function generateUserPrompt(profileName, vaultContents, maxLines) {
+	return `Generate a SKILL.md profile called "${profileName}" from the following vault content.
+Maximum ${maxLines} lines total.
+
+Required sections:
+# Personal Context — ${profileName}
+
+## Who I Am
+## Preferences
+## Hard-won Lessons
+## Current Work
+
+---VAULT CONTENT---
+${vaultContents}
+---END VAULT CONTENT---
+
+Generate the SKILL.md now. Stay within ${maxLines} lines.
+IMPORTANT: include ALL concrete facts from the vault — names, numbers, tools, project names, bookmark categories, browsing domains. Do not summarize away specific data. Never write filler or "未提供".`;
+}
+
+//#endregion
+//#region src/generate/index.ts
+/** Recursively list all markdown files in a directory */
+async function walkMd(dir) {
+	const results = [];
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...await walkMd(full));
+			else if (entry.name.endsWith(".md")) results.push(full);
+		}
+	} catch {}
+	return results;
+}
+/** Collect vault file contents matching scope patterns */
+async function collectVaultContent(scope) {
+	const vaultDir = getVaultDir();
+	const allFiles = await walkMd(vaultDir);
+	const matched = [];
+	for (const file of allFiles) {
+		const relative = "vault/" + path.relative(vaultDir, file);
+		for (const pattern of scope) if (minimatch(relative, pattern)) {
+			matched.push(file);
+			break;
+		}
+	}
+	const contents = [];
+	for (const file of matched) try {
+		const content = await fs.readFile(file, "utf-8");
+		contents.push(`--- ${path.relative(vaultDir, file)} ---\n${content}`);
+	} catch {}
+	return contents.join("\n\n");
+}
+/** Generate a single SKILL.md profile */
+async function generateProfile(profileName) {
+	const profileDef = (await loadProfiles()).profiles[profileName];
+	if (!profileDef) throw new Error(`Profile "${profileName}" not found in profiles.json5`);
+	const vaultContent = await collectVaultContent(profileDef.scope);
+	if (!vaultContent.trim()) throw new Error(`No vault content found for profile "${profileName}". Run 'pai distill' first.`);
+	const system = generateSystemPrompt();
+	const skillMd = await llmCall(generateUserPrompt(profileName, vaultContent, profileDef.maxLines), system);
+	const skillsDir = getSkillsDir();
+	await fs.mkdir(skillsDir, { recursive: true });
+	const outPath = path.join(skillsDir, `${profileName}.md`);
+	await fs.writeFile(outPath, skillMd.trim() + "\n", "utf-8");
+	return outPath;
+}
+/** Generate all profiles defined in profiles.json5 */
+async function generateAll() {
+	const profiles = await loadProfiles();
+	const profileNames = Object.keys(profiles.profiles);
+	if (profileNames.length === 0) {
+		warn("No profiles defined in profiles.json5");
+		return [];
+	}
+	const results = [];
+	for (const name of profileNames) {
+		const spin = spinner(`Generating profile: ${name}...`);
+		try {
+			const outPath = await generateProfile(name);
+			spin.succeed(`Generated ${name} → ${outPath}`);
+			results.push(outPath);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			spin.fail(`Failed to generate ${name}: ${msg}`);
+		}
+	}
+	return results;
+}
+
+//#endregion
+//#region src/profile/compile.ts
+const PROFILE_SECTIONS = [
+	{
+		heading: "Identity",
+		collectors: ["identity-profile", "github-profile"]
+	},
+	{
+		heading: "Environment & Tools",
+		collectors: ["dev-environment", "dev-preferences"]
+	},
+	{
+		heading: "Work Style & Habits",
+		collectors: ["shell-habits", "coding-rules"]
+	},
+	{
+		heading: "Active Projects & Recent Focus",
+		collectors: ["active-projects", "recent-focus"]
+	},
+	{
+		heading: "Digital Footprint",
+		collectors: [
+			"browser-bookmarks",
+			"browser-domains",
+			"productivity-setup"
+		]
+	},
+	{
+		heading: "Registry & Cloud Accounts",
+		collectors: ["social-profiles"]
+	},
+	{
+		heading: "Context",
+		collectors: ["calendar-context", "file-organization"]
+	}
+];
+/**
+* Compile CollectorResult[] into a structured profile markdown string.
+* No LLM involved — pure formatting.
+*/
+function compileProfile(results) {
+	const index = /* @__PURE__ */ new Map();
+	for (const r of results) index.set(r.id, r);
+	const sections = ["# Personal Profile", ""];
+	for (const section of PROFILE_SECTIONS) {
+		const parts = [];
+		for (const cid of section.collectors) {
+			const result = index.get(cid);
+			if (result?.content?.trim()) parts.push(result.content.trim());
+		}
+		if (parts.length === 0) continue;
+		sections.push(`## ${section.heading}`, "");
+		sections.push(parts.join("\n\n"));
+		sections.push("");
+	}
+	const coveredIds = new Set(PROFILE_SECTIONS.flatMap((s) => s.collectors));
+	const extras = [];
+	for (const r of results) if (!coveredIds.has(r.id) && r.content?.trim()) extras.push(`## ${r.title}`, "", r.content.trim(), "");
+	if (extras.length > 0) sections.push(...extras);
+	sections.push("---");
+	sections.push(`Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+	sections.push("");
+	return sections.join("\n");
+}
+
+//#endregion
+//#region src/connectors/sanitize.ts
+/**
+* Security sanitization utilities for connector-scanned content.
+* Strips secrets, credentials, and sensitive paths before writing to raw layer.
+*/
+/** Pattern matching shell export lines containing secrets */
+const SECRET_EXPORT_RE = /^(\s*export\s+)\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|PASSWD)\w*\s*=.*/i;
+/** Pattern matching lines that look like inline secret assignments (no export) */
+const SECRET_ASSIGN_RE = /^\s*\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|PASSWD)\w*\s*=\s*["']?\S+/i;
+/**
+* Strip secret export/assignment lines from shell config content.
+* Preserves comments and non-secret lines intact.
+*/
+function stripSecretExports(content) {
+	return content.split("\n").map((line) => {
+		if (SECRET_EXPORT_RE.test(line) || SECRET_ASSIGN_RE.test(line)) return "# [REDACTED by pai — secret removed]";
+		return line;
+	}).join("\n");
+}
+/**
+* Strip [credential] sections from git config content.
+* Removes the section header and all lines until the next section.
+*/
+function stripGitCredentials(content) {
+	const lines = content.split("\n");
+	const result = [];
+	let inCredentialSection = false;
+	for (const line of lines) {
+		if (/^\s*\[credential/i.test(line)) {
+			inCredentialSection = true;
+			result.push("# [REDACTED by pai — credential section removed]");
+			continue;
+		}
+		if (inCredentialSection && /^\s*\[/.test(line)) inCredentialSection = false;
+		if (!inCredentialSection) result.push(line);
+	}
+	return result.join("\n");
+}
+/**
+* Strip IdentityFile lines from SSH config.
+* Keeps Host, HostName, User, Port — removes key paths.
+*/
+function stripSshIdentityFiles(content) {
+	return content.split("\n").map((line) => {
+		if (/^\s*IdentityFile\s/i.test(line)) return "  # [REDACTED by pai — IdentityFile removed]";
+		return line;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/connectors/mac/collectors.ts
+/**
+* Mac system context collectors.
+* Each collector gathers a specific category of personalized context
+* from the local macOS environment and returns a CollectorResult.
+*/
+/** Run a shell command and return stdout (empty string on failure) */
+async function exec(cmd, args) {
+	return new Promise((resolve) => {
+		execFile(cmd, args, {
+			encoding: "utf-8",
+			timeout: 15e3
+		}, (err, stdout) => {
+			resolve(err ? "" : stdout.trim());
+		});
+	});
+}
+/** Read a file, return empty string on failure */
+async function readSafe(filePath) {
+	try {
+		return await fs.readFile(filePath, "utf-8");
+	} catch {
+		return "";
+	}
+}
+/** Check if path exists */
+async function exists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Run osascript and return output */
+async function osascript(script) {
+	return exec("osascript", ["-e", script]);
+}
+/** Run defaults read and return output */
+async function defaultsRead(...args) {
+	return exec("defaults", ["read", ...args]);
+}
+const HOME = os.homedir();
+async function collectIdentityProfile() {
+	const lines = ["## User Identity"];
+	const username = await exec("id", ["-un"]);
+	if (username) lines.push(`- macOS Username: ${username}`);
+	const nameMatch = (await exec("dscl", [
+		".",
+		"-read",
+		`/Users/${username}`,
+		"RealName"
+	])).split("\n").find((l) => l.trim() && !l.includes("RealName"));
+	if (nameMatch?.trim()) lines.push(`- Real Name (local): ${nameMatch.trim()}`);
+	const mobileMe = await defaultsRead("MobileMeAccounts");
+	const appleIdMatch = mobileMe.match(/AccountID\s*=\s*"?([^";\n]+)/);
+	const displayNameMatch = mobileMe.match(/DisplayName\s*=\s*"?([^";\n]+)/);
+	if (displayNameMatch) lines.push(`- Apple ID Display Name: ${displayNameMatch[1].trim()}`);
+	if (appleIdMatch) lines.push(`- Apple ID: ${appleIdMatch[1].trim()}`);
+	const computerName = await exec("scutil", ["--get", "ComputerName"]);
+	if (computerName) lines.push(`- Computer Name: ${computerName}`);
+	const gitName = await exec("git", [
+		"config",
+		"--global",
+		"user.name"
+	]);
+	const gitEmail = await exec("git", [
+		"config",
+		"--global",
+		"user.email"
+	]);
+	if (gitName) lines.push(`- Git Name: ${gitName}`);
+	if (gitEmail) lines.push(`- Git Email: ${gitEmail}`);
+	lines.push("", "## Locale & Language");
+	const langList = (await defaultsRead("NSGlobalDomain", "AppleLanguages")).match(/"([^"]+)"/g)?.map((s) => s.replace(/"/g, "")) ?? [];
+	if (langList.length > 0) lines.push(`- Languages: ${langList.join(", ")}`);
+	const locale = await defaultsRead("NSGlobalDomain", "AppleLocale");
+	if (locale) lines.push(`- Locale: ${locale}`);
+	const inputSources = await defaultsRead("com.apple.HIToolbox", "AppleSelectedInputSources");
+	const inputMethods = inputSources.match(/"Input Mode"\s*=\s*"([^"]+)"/g) ?? [];
+	const bundleIds = inputSources.match(/"Bundle ID"\s*=\s*"([^"]+)"/g) ?? [];
+	const inputs = [...inputMethods, ...bundleIds].map((s) => s.replace(/.*"([^"]+)"$/, "$1")).filter((s) => !s.includes("PressAndHold"));
+	if (inputs.length > 0) lines.push(`- Input Methods: ${inputs.join(", ")}`);
+	const appearance = await defaultsRead("-g", "AppleInterfaceStyle");
+	lines.push(`- System Appearance: ${appearance || "Light"}`);
+	const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+	lines.push(`- Timezone: ${tz}`);
+	return {
+		id: "identity-profile",
+		title: "Mac User Identity Profile",
+		content: lines.join("\n")
+	};
+}
+async function collectCalendarContext() {
+	let calNames = [];
+	const raw = await osascript("tell application \"Calendar\" to get name of every calendar");
+	if (raw) calNames = raw.split(", ").map((s) => s.trim()).filter(Boolean);
+	const lines = [
+		"## Calendar Subscriptions",
+		"",
+		`Total calendars: ${calNames.length}`,
+		"",
+		...calNames.map((name) => `- ${name}`)
+	];
+	return {
+		id: "calendar-context",
+		title: "Calendar Context",
+		content: calNames.length > 0 ? lines.join("\n") : "No calendar data accessible (Calendar app may not be running)."
+	};
+}
+async function collectFileOrganization() {
+	const lines = [];
+	const docsDir = path.join(HOME, "Documents");
+	try {
+		const dirs = (await fs.readdir(docsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+		lines.push("## Documents Folders", "", ...dirs.map((d) => `- ${d}`));
+	} catch {
+		lines.push("## Documents Folders", "", "(not accessible)");
+	}
+	const desktopDir = path.join(HOME, "Desktop");
+	try {
+		const entries = await fs.readdir(desktopDir);
+		lines.push("", "## Desktop Items", "", ...entries.slice(0, 20).map((e) => `- ${e}`));
+		if (entries.length > 20) lines.push(`- ... and ${entries.length - 20} more`);
+	} catch {
+		lines.push("", "## Desktop Items", "", "(not accessible)");
+	}
+	const dlDir = path.join(HOME, "Downloads");
+	try {
+		const entries = await fs.readdir(dlDir);
+		lines.push("", "## Recent Downloads (latest 15 by name)", "", ...entries.slice(0, 15).map((e) => `- ${e}`));
+	} catch {
+		lines.push("", "## Recent Downloads", "", "(not accessible)");
+	}
+	return {
+		id: "file-organization",
+		title: "File Organization Structure",
+		content: lines.join("\n")
+	};
+}
+async function collectDevEnvironment() {
+	const lines = ["## Runtime Versions"];
+	for (const [name, cmd, args] of [
+		[
+			"Node.js",
+			"node",
+			["--version"]
+		],
+		[
+			"Python",
+			"python3",
+			["--version"]
+		],
+		[
+			"Go",
+			"go",
+			["version"]
+		],
+		[
+			"Rust",
+			"rustc",
+			["--version"]
+		],
+		[
+			"Java",
+			"java",
+			["--version"]
+		]
+	]) {
+		const ver = await exec(cmd, args);
+		if (ver) {
+			const first = ver.split("\n")[0] ?? ver;
+			lines.push(`- ${name}: ${first}`);
+		}
+	}
+	lines.push("", "## Package Managers");
+	for (const pm of [
+		"brew",
+		"pnpm",
+		"npm",
+		"pip3",
+		"cargo"
+	]) {
+		const which = await exec("which", [pm]);
+		if (which) lines.push(`- ${pm}: ${which}`);
+	}
+	const docker = await exec("docker", ["--version"]);
+	if (docker) lines.push("", "## Docker", "", `- ${docker}`);
+	lines.push("", "## Shell");
+	const shell = process.env.SHELL ?? "";
+	lines.push(`- Shell: ${shell}`);
+	const zshrc = await readSafe(path.join(HOME, ".zshrc"));
+	const themeMatch = zshrc.match(/^ZSH_THEME="?([^"\n]+)/m);
+	const pluginsMatch = zshrc.match(/^plugins=\(([^)]+)\)/m);
+	if (themeMatch) lines.push(`- Oh-My-Zsh Theme: ${themeMatch[1]}`);
+	if (pluginsMatch) lines.push(`- Oh-My-Zsh Plugins: ${pluginsMatch[1].trim()}`);
+	const npmGlobal = await exec("npm", [
+		"list",
+		"-g",
+		"--depth=0"
+	]);
+	if (npmGlobal) {
+		const pkgs = npmGlobal.split("\n").filter((l) => l.startsWith("├") || l.startsWith("└")).map((l) => l.replace(/^[├└─┬│\s]+/, "").trim()).filter(Boolean);
+		if (pkgs.length > 0) lines.push("", "## Global npm Packages", "", ...pkgs.map((p) => `- ${p}`));
+	}
+	const casks = await exec("brew", ["list", "--cask"]);
+	if (casks) {
+		const caskList = casks.split("\n").filter(Boolean);
+		lines.push("", "## Homebrew Casks", "", ...caskList.map((c) => `- ${c}`));
+	}
+	return {
+		id: "dev-environment",
+		title: "Development Environment",
+		content: lines.join("\n")
+	};
+}
+async function collectDevPreferences() {
+	const lines = [];
+	const zshrc = await readSafe(path.join(HOME, ".zshrc"));
+	if (zshrc) {
+		const sanitized = stripSecretExports(zshrc);
+		const aliases = sanitized.split("\n").filter((l) => l.match(/^\s*alias\s/));
+		if (aliases.length > 0) lines.push("## Shell Aliases", "", ...aliases);
+		const pathLines = sanitized.split("\n").filter((l) => l.match(/^\s*export\s+PATH/) && !l.includes("REDACTED"));
+		if (pathLines.length > 0) lines.push("", "## PATH Additions", "", ...pathLines);
+	}
+	const gitconfig = await readSafe(path.join(HOME, ".gitconfig"));
+	if (gitconfig) {
+		const sanitized = stripGitCredentials(gitconfig);
+		lines.push("", "## Git Config", "", "```", sanitized.trim(), "```");
+	}
+	const gitAliases = await exec("git", [
+		"config",
+		"--global",
+		"--get-regexp",
+		"alias"
+	]);
+	if (gitAliases) lines.push("", "## Git Aliases", "", ...gitAliases.split("\n").map((l) => `- ${l}`));
+	const defaultBranch = await exec("git", [
+		"config",
+		"--global",
+		"init.defaultBranch"
+	]);
+	if (defaultBranch) lines.push("", `## Default Git Branch: ${defaultBranch}`);
+	const extDir = path.join(HOME, ".cursor", "extensions");
+	try {
+		const exts = (await fs.readdir(extDir)).filter((e) => !e.startsWith(".") && e !== "extensions.json");
+		if (exts.length > 0) lines.push("", "## Cursor Extensions", "", ...exts.map((e) => `- ${e}`));
+	} catch {}
+	return {
+		id: "dev-preferences",
+		title: "Development Preferences",
+		content: lines.join("\n")
+	};
+}
+async function collectShellHabits() {
+	const raw = await readSafe(path.join(HOME, ".zsh_history"));
+	if (!raw) return {
+		id: "shell-habits",
+		title: "Shell Command Habits",
+		content: "No zsh history found."
+	};
+	const rawLines = raw.split("\n");
+	const totalEntries = rawLines.length;
+	const freq = /* @__PURE__ */ new Map();
+	for (const line of rawLines) {
+		const firstWord = line.replace(/^:\s*\d+:\d+;/, "").trim().split(/\s+/)[0];
+		if (firstWord && firstWord.length > 0 && firstWord.length < 50) freq.set(firstWord, (freq.get(firstWord) ?? 0) + 1);
+	}
+	const top30 = [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 30);
+	return {
+		id: "shell-habits",
+		title: "Shell Command Habits",
+		content: [
+			`Total history entries: ${totalEntries}`,
+			"",
+			"## Most Used Commands (Top 30)",
+			"",
+			...top30.map(([cmd, count]) => `- ${cmd}: ${count} times`)
+		].join("\n")
+	};
+}
+async function collectCodingRules() {
+	const sections = [];
+	const claudePaths = [path.join(HOME, "CLAUDE.md"), path.join(HOME, ".claude", "CLAUDE.md")];
+	for (const p of claudePaths) {
+		const content = await readSafe(p);
+		if (content) {
+			const relPath = p.replace(HOME, "~");
+			sections.push(`## ${relPath}`, "", content.trim(), "");
+		}
+	}
+	const cmdDir = path.join(HOME, ".claude", "commands");
+	try {
+		const mdFiles = (await fs.readdir(cmdDir)).filter((e) => e.endsWith(".md"));
+		if (mdFiles.length > 0) {
+			sections.push("## Claude Custom Commands", "");
+			for (const f of mdFiles) {
+				const content = await readSafe(path.join(cmdDir, f));
+				if (content) sections.push(`### ${f}`, "", content.trim(), "");
+			}
+		}
+	} catch {}
+	const activeRepos = await findRecentGitRepos(30);
+	const projectRules = [];
+	for (const repo of activeRepos.slice(0, 10)) for (const ruleFile of [
+		"CLAUDE.md",
+		"AGENTS.md",
+		".cursorrules"
+	]) {
+		const content = await readSafe(path.join(repo, ruleFile));
+		if (content && content.length > 10) {
+			const repoName = path.basename(repo);
+			projectRules.push(`### ${repoName}/${ruleFile}`, "", content.trim().slice(0, 2e3), "");
+		}
+	}
+	if (projectRules.length > 0) sections.push("## Project-Level Rules", "", ...projectRules);
+	const cursorRulesDir = path.join(HOME, ".cursor", "rules");
+	try {
+		const mdFiles = (await fs.readdir(cursorRulesDir)).filter((e) => e.endsWith(".md") || e.endsWith(".mdc"));
+		if (mdFiles.length > 0) {
+			sections.push("## Global Cursor Rules", "");
+			for (const f of mdFiles) {
+				const content = await readSafe(path.join(cursorRulesDir, f));
+				if (content) sections.push(`### ${f}`, "", content.trim().slice(0, 1e3), "");
+			}
+		}
+	} catch {}
+	return {
+		id: "coding-rules",
+		title: "Coding Rules and AI Agent Config",
+		content: sections.length > 0 ? sections.join("\n") : "No coding rules found."
+	};
+}
+async function collectActiveProjects() {
+	const lines = [];
+	const repos = await findRecentGitRepos(30);
+	if (repos.length > 0) {
+		lines.push("## Active Git Repositories (last 30 days)", "");
+		for (const repo of repos) {
+			const name = repo.replace(HOME, "~");
+			lines.push(`- ${name}`);
+		}
+	}
+	const sshConfig = await readSafe(path.join(HOME, ".ssh", "config"));
+	if (sshConfig) {
+		const hosts = stripSshIdentityFiles(sshConfig).split("\n").filter((l) => /^\s*Host\s/i.test(l) && !l.includes("*")).map((l) => l.replace(/^\s*Host\s+/i, "").trim());
+		if (hosts.length > 0) lines.push("", "## SSH Hosts", "", ...hosts.map((h) => `- ${h}`));
+	}
+	const cloudDir = path.join(HOME, "Library", "CloudStorage");
+	try {
+		const entries = await fs.readdir(cloudDir);
+		if (entries.length > 0) lines.push("", "## Cloud Storage", "", ...entries.map((e) => `- ${e}`));
+	} catch {}
+	return {
+		id: "active-projects",
+		title: "Active Projects and Infrastructure",
+		content: lines.join("\n")
+	};
+}
+async function collectProductivitySetup() {
+	const lines = [];
+	try {
+		const apps = (await fs.readdir("/Applications")).filter((e) => e.endsWith(".app")).map((e) => e.replace(".app", ""));
+		lines.push("## Installed Applications", "", ...apps.map((a) => `- ${a}`));
+	} catch {
+		lines.push("## Installed Applications", "", "(not accessible)");
+	}
+	const dockApps = await defaultsRead("com.apple.dock", "persistent-apps");
+	if (dockApps) {
+		const labels = [...dockApps.matchAll(/"file-label"\s*=\s*"?([^";\n}]+)/g)].map((m) => m[1].trim()).filter(Boolean);
+		if (labels.length > 0) lines.push("", "## Dock Apps (pinned)", "", ...labels.map((a) => `- ${a}`));
+	}
+	const browserMatch = (await defaultsRead("com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers")).match(/LSHandlerRoleAll\s*=\s*"([^"]+)"/);
+	if (browserMatch) {
+		const bundleId = browserMatch[1];
+		const browserName = bundleId.includes("edge") ? "Microsoft Edge" : bundleId.includes("chrome") ? "Google Chrome" : bundleId.includes("firefox") ? "Firefox" : bundleId.includes("safari") ? "Safari" : bundleId;
+		lines.push("", `## Default Browser: ${browserName}`);
+	}
+	const resolutions = [...(await exec("system_profiler", ["SPDisplaysDataType"])).matchAll(/Resolution:\s*(.+)/g)].map((m) => m[1].trim());
+	if (resolutions.length > 0) lines.push("", "## Screen Resolution", "", ...resolutions.map((r) => `- ${r}`));
+	return {
+		id: "productivity-setup",
+		title: "Productivity Setup",
+		content: lines.join("\n")
+	};
+}
+async function collectBrowserBookmarks() {
+	const raw = await readSafe(path.join(HOME, "Library", "Application Support", "Microsoft Edge", "Default", "Bookmarks"));
+	if (!raw) return {
+		id: "browser-bookmarks",
+		title: "Browser Bookmark Structure",
+		content: "No Edge bookmarks found."
+	};
+	try {
+		const data = JSON.parse(raw);
+		const folders = [];
+		let totalUrls = 0;
+		function walk(node, depth) {
+			if (node.type === "folder") {
+				const children = node.children ?? [];
+				const name = node.name ?? "";
+				if (children.length > 0) folders.push({
+					name,
+					count: children.length,
+					depth
+				});
+				for (const child of children) walk(child, depth + 1);
+			} else if (node.type === "url") totalUrls++;
+		}
+		const roots = data.roots;
+		for (const root of Object.values(roots)) if (root && typeof root === "object" && "children" in root) walk(root, 0);
+		folders.sort((a, b) => b.count - a.count);
+		return {
+			id: "browser-bookmarks",
+			title: "Browser Bookmark Structure",
+			content: [
+				`Total bookmarks: ${totalUrls}`,
+				`Total folders: ${folders.length}`,
+				"",
+				"## Top Bookmark Folders (by item count)",
+				"",
+				...folders.slice(0, 40).map((f) => `- ${"  ".repeat(Math.min(f.depth, 2))}${f.name}: ${f.count} items`)
+			].join("\n")
+		};
+	} catch {
+		return {
+			id: "browser-bookmarks",
+			title: "Browser Bookmark Structure",
+			content: "Failed to parse Edge bookmarks."
+		};
+	}
+}
+async function collectBrowserDomains() {
+	const histPath = path.join(HOME, "Library", "Application Support", "Microsoft Edge", "Default", "History");
+	if (!await exists(histPath)) return {
+		id: "browser-domains",
+		title: "Browser Top Domains (30 days)",
+		content: "No Edge history found."
+	};
+	const tmpDb = path.join(os.tmpdir(), `pai-edge-history-${Date.now()}.db`);
+	try {
+		await fs.copyFile(histPath, tmpDb);
+		const output = await exec("sqlite3", [tmpDb, `
+      SELECT
+        REPLACE(REPLACE(SUBSTR(url, 1, INSTR(SUBSTR(url, 9), '/') + 8), 'https://', ''), 'http://', '') as domain,
+        COUNT(*) as visits
+      FROM urls
+      WHERE last_visit_time > (strftime('%s', 'now', '-30 days') + 11644473600) * 1000000
+      GROUP BY domain
+      ORDER BY visits DESC
+      LIMIT 30;
+    `.trim()]);
+		if (!output) return {
+			id: "browser-domains",
+			title: "Browser Top Domains (30 days)",
+			content: "Could not query Edge history (DB may be locked)."
+		};
+		return {
+			id: "browser-domains",
+			title: "Browser Top Domains (30 days)",
+			content: [
+				"## Top 30 Domains (last 30 days)",
+				"",
+				...output.split("\n").map((line) => {
+					const [domain, visits] = line.split("|");
+					return `- ${domain}: ${visits} visits`;
+				})
+			].join("\n")
+		};
+	} finally {
+		try {
+			await fs.unlink(tmpDb);
+		} catch {}
+	}
+}
+async function collectGitHubProfile() {
+	const lines = [];
+	if (!await exec("gh", ["--version"])) return {
+		id: "github-profile",
+		title: "GitHub Profile",
+		content: "GitHub CLI (gh) not installed."
+	};
+	if (!await exec("gh", ["auth", "status"])) return {
+		id: "github-profile",
+		title: "GitHub Profile",
+		content: "GitHub CLI not authenticated. Run `gh auth login` to enable."
+	};
+	const userJson = await exec("gh", [
+		"api",
+		"user",
+		"--jq",
+		"[.login, .name, .bio, .company, .location, .blog, .public_repos, .followers, .following, .created_at] | @tsv"
+	]);
+	if (userJson) {
+		const [login, name, bio, company, location, blog, publicRepos, followers, following, createdAt] = userJson.split("	");
+		lines.push("## GitHub Profile", "");
+		if (login) lines.push(`- Username: ${login}`);
+		if (name) lines.push(`- Name: ${name}`);
+		if (bio) lines.push(`- Bio: ${bio}`);
+		if (company) lines.push(`- Company: ${company}`);
+		if (location) lines.push(`- Location: ${location}`);
+		if (blog) lines.push(`- Website: ${blog}`);
+		if (publicRepos) lines.push(`- Public Repos: ${publicRepos}`);
+		if (followers || following) lines.push(`- Followers/Following: ${followers}/${following}`);
+		if (createdAt) lines.push(`- Member since: ${createdAt}`);
+	}
+	const reposJson = await exec("gh", [
+		"repo",
+		"list",
+		"--limit",
+		"10",
+		"--sort",
+		"updated",
+		"--json",
+		"name,description,primaryLanguage,pushedAt,isPrivate",
+		"--jq",
+		".[] | [.name, .description, (.primaryLanguage.name // \"\"), .pushedAt, .isPrivate] | @tsv"
+	]);
+	if (reposJson) {
+		const repos = reposJson.split("\n").filter(Boolean);
+		if (repos.length > 0) {
+			lines.push("", "## Recent GitHub Repos (by push date)", "");
+			for (const repo of repos) {
+				const [name, desc, lang, _pushed, isPrivate] = repo.split("	");
+				const visibility = isPrivate === "true" ? "private" : "public";
+				const langTag = lang ? ` [${lang}]` : "";
+				const descTag = desc ? ` — ${desc}` : "";
+				lines.push(`- ${name}${langTag} (${visibility})${descTag}`);
+			}
+		}
+	}
+	const starsJson = await exec("gh", [
+		"api",
+		"user/starred?per_page=20&sort=created&direction=desc",
+		"--jq",
+		".[].full_name"
+	]);
+	if (starsJson) {
+		const stars = starsJson.split("\n").filter(Boolean);
+		if (stars.length > 0) {
+			lines.push("", "## Recently Starred Repos (interest signals)", "");
+			lines.push(stars.map((s) => `- ${s}`).join("\n"));
+		}
+	}
+	return {
+		id: "github-profile",
+		title: "GitHub Profile & Activity",
+		content: lines.length > 0 ? lines.join("\n") : "No GitHub data accessible."
+	};
+}
+async function collectRecentFocus() {
+	const lines = [];
+	const repos = await findRecentGitRepos(14);
+	const commitTopics = /* @__PURE__ */ new Map();
+	const recentMessages = [];
+	for (const repo of repos.slice(0, 8)) {
+		const log = await exec("git", [
+			"-C",
+			repo,
+			"log",
+			"--oneline",
+			"--since=14 days ago",
+			"--format=%s",
+			"-n",
+			"20"
+		]);
+		if (log) for (const msg of log.split("\n").filter(Boolean)) {
+			recentMessages.push(msg);
+			const type = msg.match(/^(feat|fix|refactor|test|docs|chore|perf|ci|build|style)/i);
+			if (type) {
+				const key = type[1].toLowerCase();
+				commitTopics.set(key, (commitTopics.get(key) ?? 0) + 1);
+			}
+		}
+	}
+	if (commitTopics.size > 0) {
+		const sorted = [...commitTopics.entries()].sort((a, b) => b[1] - a[1]);
+		lines.push("## Recent Commit Activity (last 2 weeks)", "");
+		lines.push(`Total commits analyzed: ${recentMessages.length}`);
+		lines.push("", "Commit types:");
+		for (const [type, count] of sorted) lines.push(`- ${type}: ${count}`);
+	}
+	if (recentMessages.length > 0) {
+		lines.push("", "## Recent Commit Messages (sample)", "");
+		const unique = [...new Set(recentMessages)].slice(0, 15);
+		for (const msg of unique) lines.push(`- ${msg}`);
+	}
+	const histRaw = await readSafe(path.join(HOME, ".zsh_history"));
+	if (histRaw) {
+		const recent = histRaw.split("\n").slice(-200);
+		const cdPaths = /* @__PURE__ */ new Map();
+		const tools = /* @__PURE__ */ new Map();
+		for (const line of recent) {
+			const cmd = line.replace(/^:\s*\d+:\d+;/, "").trim();
+			const cdMatch = cmd.match(/^cd\s+(.+)/);
+			if (cdMatch) {
+				const dest = cdMatch[1].trim().replace(/^~/, HOME);
+				cdPaths.set(dest, (cdPaths.get(dest) ?? 0) + 1);
+			}
+			const toolMatch = cmd.match(/^(docker|kubectl|terraform|aws|gcloud|firebase|vercel|netlify|npm|pnpm|yarn|bun|cargo|go|python|pip|uv)\b/);
+			if (toolMatch) tools.set(toolMatch[1], (tools.get(toolMatch[1]) ?? 0) + 1);
+		}
+		if (cdPaths.size > 0) {
+			const topDirs = [...cdPaths.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
+			lines.push("", "## Recent Working Directories", "");
+			for (const [dir, count] of topDirs) lines.push(`- ${dir.replace(HOME, "~")}: ${count}x`);
+		}
+		if (tools.size > 0) {
+			const topTools = [...tools.entries()].sort((a, b) => b[1] - a[1]);
+			lines.push("", "## Recently Used Tools (from history)", "");
+			for (const [tool, count] of topTools) lines.push(`- ${tool}: ${count}x`);
+		}
+	}
+	return {
+		id: "recent-focus",
+		title: "Recent Focus & Activity",
+		content: lines.length > 0 ? lines.join("\n") : "No recent activity data found."
+	};
+}
+async function collectSocialProfiles() {
+	const lines = [];
+	const npmrc = await readSafe(path.join(HOME, ".npmrc"));
+	if (npmrc) {
+		const registryMatch = npmrc.match(/^registry\s*=\s*(.+)/m);
+		if (registryMatch) lines.push(`- npm registry: ${registryMatch[1].trim()}`);
+		const scopes = npmrc.match(/^@[\w-]+:registry/gm);
+		if (scopes) for (const s of scopes) lines.push(`- npm scope: ${s.split(":")[0]}`);
+	}
+	const npmUser = await exec("npm", ["whoami"]);
+	if (npmUser) lines.push(`- npm username: ${npmUser}`);
+	const pypirc = await readSafe(path.join(HOME, ".pypirc"));
+	if (pypirc) {
+		const repoMatch = pypirc.match(/repository\s*=\s*(.+)/);
+		if (repoMatch) lines.push(`- PyPI repository: ${repoMatch[1].trim()}`);
+		const usernameMatch = pypirc.match(/username\s*=\s*(.+)/);
+		if (usernameMatch) lines.push(`- PyPI username: ${usernameMatch[1].trim()}`);
+	}
+	const dockerConfig = await readSafe(path.join(HOME, ".docker", "config.json"));
+	if (dockerConfig) try {
+		const cfg = JSON.parse(dockerConfig);
+		const auths = Object.keys(cfg.auths ?? {});
+		if (auths.length > 0) lines.push(`- Docker registries: ${auths.join(", ")}`);
+	} catch {}
+	const cargoConfig = await readSafe(path.join(HOME, ".cargo", "config.toml"));
+	if (cargoConfig) {
+		const registries = cargoConfig.match(/\[registries\.(\w+)\]/g);
+		if (registries) lines.push(`- Cargo registries: ${registries.map((r) => r.replace(/\[registries\.|\]/g, "")).join(", ")}`);
+	}
+	const awsIdentity = await exec("aws", [
+		"sts",
+		"get-caller-identity",
+		"--query",
+		"Account",
+		"--output",
+		"text"
+	]);
+	if (awsIdentity) lines.push(`- AWS Account: ${awsIdentity}`);
+	const gcpProject = await exec("gcloud", [
+		"config",
+		"get-value",
+		"project"
+	]);
+	if (gcpProject && !gcpProject.includes("unset")) lines.push(`- GCP Project: ${gcpProject}`);
+	const vercelUser = await exec("vercel", ["whoami"]);
+	if (vercelUser) lines.push(`- Vercel: ${vercelUser}`);
+	return {
+		id: "social-profiles",
+		title: "Registry & Cloud Profiles",
+		content: lines.length > 0 ? [
+			"## Registry & Cloud Accounts",
+			"",
+			...lines
+		].join("\n") : "No registry or cloud profiles detected."
+	};
+}
+/** Find git repos under ~/Documents modified in the last N days */
+async function findRecentGitRepos(days) {
+	const output = await exec("find", [
+		path.join(HOME, "Documents"),
+		"-maxdepth",
+		"4",
+		"-name",
+		".git",
+		"-type",
+		"d",
+		"-mtime",
+		`-${days}`
+	]);
+	if (!output) return [];
+	return output.split("\n").filter(Boolean).map((p) => p.replace(/\/.git$/, ""));
+}
+/** All available Mac collectors in execution order */
+const ALL_COLLECTORS = [
+	collectIdentityProfile,
+	collectCalendarContext,
+	collectFileOrganization,
+	collectDevEnvironment,
+	collectDevPreferences,
+	collectShellHabits,
+	collectCodingRules,
+	collectActiveProjects,
+	collectProductivitySetup,
+	collectBrowserBookmarks,
+	collectBrowserDomains,
+	collectGitHubProfile,
+	collectRecentFocus,
+	collectSocialProfiles
+];
+
+//#endregion
+//#region src/profile/index.ts
+/**
+* Profile module — compile, load, and rebuild user profiles.
+*/
+/** Load the current profile from disk. Returns null if not found. */
+async function loadProfile() {
+	try {
+		return await fs.readFile(getProfilePath(), "utf-8");
+	} catch {
+		return null;
+	}
+}
+/** Save profile markdown to disk. */
+async function saveProfile(content) {
+	const profilePath = getProfilePath();
+	await fs.writeFile(profilePath, content, "utf-8");
+	return profilePath;
+}
+/**
+* Full rebuild: scan local machine → compile profile → write to disk.
+* Also writes raw files for the scan data (for vault/distill pipeline compatibility).
+*/
+async function rebuildProfile(opts) {
+	const verbose = opts?.verbose ?? true;
+	const spin = verbose ? spinner("Scanning local machine...") : null;
+	const settled = await Promise.allSettled(ALL_COLLECTORS.map((collector) => collector()));
+	const results = [];
+	const failed = [];
+	for (let i = 0; i < settled.length; i++) {
+		const s = settled[i];
+		if (s.status === "fulfilled") results.push(s.value);
+		else {
+			const name = ALL_COLLECTORS[i].name;
+			failed.push(name);
+			if (verbose) warn(`Collector ${name} failed: ${String(s.reason)}`);
+		}
+	}
+	spin?.succeed(`Scanned ${results.length} sources (${failed.length} failed)`);
+	if (!opts?.skipRaw) for (const entry of results) try {
+		await addConnectorEntry("mac", entry);
+	} catch {}
+	return {
+		profilePath: await saveProfile(compileProfile(results)),
+		results
+	};
+}
+
+//#endregion
+export { addFile, addText, addUrl, compileProfile, distillPipeline, generateAll, generateProfile, listPending, llmCall, loadConfig, loadProfile, loadProfiles, rebuildProfile, scrapeUrl, search, updateIndex };
+//# sourceMappingURL=index.mjs.map