claude-alfred 0.1.0

package/dist/helpers-BsdW4kgn.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { o as incrementHitCount, r as getKnowledgeByIDs, u as searchKnowledgeKeyword } from "./knowledge-CCCixwb8.mjs";
+import { r as vectorSearchKnowledge } from "./vectors-DvuAqDeO.mjs";
+import { i as subTypeHalfLife, n as searchKnowledgeFTS, r as subTypeBoost } from "./fts-BDdUbNfM.mjs";
+//#region src/mcp/helpers.ts
+const RECENCY_FLOOR = .5;
+function truncate(s, maxLen) {
+	const runes = [...s];
+	if (runes.length <= maxLen) return s;
+	return runes.slice(0, maxLen).join("") + "...";
+}
+function recencyFactor(createdAt, subType, now) {
+	const halfLife = subTypeHalfLife(subType);
+	if (halfLife <= 0) return 1;
+	const parsed = Date.parse(createdAt);
+	if (isNaN(parsed)) return 1;
+	const ageDays = (now.getTime() - parsed) / (1e3 * 60 * 60 * 24);
+	if (ageDays <= 0) return 1;
+	const factor = Math.exp(-Math.LN2 * ageDays / halfLife);
+	return factor < RECENCY_FLOOR ? RECENCY_FLOOR : factor;
+}
+function applyRecencySignal(docs, now) {
+	if (docs.length === 0) return docs;
+	const scored = docs.map((doc, i) => {
+		const posScore = 1 / (i + 1);
+		const rf = recencyFactor(doc.createdAt, doc.subType, now);
+		const stb = subTypeBoost(doc.subType);
+		return {
+			doc,
+			score: posScore * rf * stb
+		};
+	});
+	if (scored.length > 1) scored.sort((a, b) => b.score - a.score);
+	return scored.map((s) => s.doc);
+}
+async function searchPipeline(store, emb, query, limit, overRetrieve) {
+	const res = {
+		docs: [],
+		searchMethod: "",
+		warnings: []
+	};
+	if (emb) try {
+		const matches = vectorSearchKnowledge(store, await emb.embedForSearch(query), overRetrieve);
+		if (matches.length > 0) {
+			const ids = matches.map((m) => m.sourceId);
+			const docs = getKnowledgeByIDs(store, ids);
+			const docMap = new Map(docs.map((d) => [d.id, d]));
+			const ordered = [];
+			for (const id of ids) {
+				const d = docMap.get(id);
+				if (d) ordered.push(d);
+			}
+			res.docs = ordered;
+			res.searchMethod = "vector";
+			if (res.docs.length > limit) try {
+				const contents = res.docs.map((d) => d.title + "\n" + d.content);
+				const reranked = await emb.rerank(query, contents, limit);
+				if (reranked.length > 0) {
+					const reorderedDocs = [];
+					for (const r of reranked) if (r.index >= 0 && r.index < res.docs.length) reorderedDocs.push(res.docs[r.index]);
+					res.docs = reorderedDocs;
+					res.searchMethod = "vector+rerank";
+				}
+			} catch (err) {
+				res.warnings.push(`rerank failed: ${err}`);
+			}
+		}
+	} catch (err) {
+		res.warnings.push(`vector embedding failed: ${err}`);
+	}
+	if (res.docs.length === 0) {
+		res.searchMethod = "fts5";
+		try {
+			res.docs = searchKnowledgeFTS(store, query, limit);
+		} catch (err) {
+			res.warnings.push(`fts5 search failed: ${err}`);
+			res.searchMethod = "keyword";
+			try {
+				res.docs = searchKnowledgeKeyword(store, query, limit);
+			} catch (err2) {
+				res.warnings.push(`keyword search failed: ${err2}`);
+			}
+		}
+	}
+	res.docs = applyRecencySignal(res.docs, /* @__PURE__ */ new Date());
+	if (res.docs.length > limit) res.docs = res.docs.slice(0, limit);
+	return res;
+}
+function trackHitCounts(store, docs) {
+	if (docs.length === 0) return;
+	incrementHitCount(store, docs.filter((d) => d.id > 0).map((d) => d.id));
+}
+//#endregion
+export { trackHitCounts as n, truncate as r, searchPipeline as t };

package/dist/knowledge-CCCixwb8.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+//#region src/store/knowledge.ts
+function contentHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+function upsertKnowledge(store, row) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	if (!row.createdAt) row.createdAt = now;
+	row.updatedAt = now;
+	row.contentHash = contentHash(row.content);
+	const existing = store.db.prepare("SELECT id, content_hash FROM knowledge_index WHERE project_remote = ? AND project_path = ? AND file_path = ?").get(row.projectRemote, row.projectPath, row.filePath);
+	if (existing && existing.content_hash === row.contentHash) {
+		row.id = existing.id;
+		return {
+			id: existing.id,
+			changed: false
+		};
+	}
+	const result = store.db.prepare(`
+    INSERT INTO knowledge_index
+    (file_path, content_hash, title, content, sub_type,
+     project_remote, project_path, project_name, branch,
+     created_at, updated_at, hit_count, last_accessed, enabled)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, '', 1)
+    ON CONFLICT(project_remote, project_path, file_path) DO UPDATE SET
+     content_hash = excluded.content_hash,
+     title = excluded.title,
+     content = excluded.content,
+     sub_type = excluded.sub_type,
+     project_name = excluded.project_name,
+     branch = excluded.branch,
+     updated_at = excluded.updated_at
+  `).run(row.filePath, row.contentHash, row.title, row.content, row.subType, row.projectRemote, row.projectPath, row.projectName, row.branch, row.createdAt, row.updatedAt);
+	const id = Number(result.lastInsertRowid);
+	row.id = id;
+	return {
+		id,
+		changed: true
+	};
+}
+function getKnowledgeByID(store, id) {
+	const row = store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index WHERE id = ?
+  `).get(id);
+	return row ? mapRow(row) : void 0;
+}
+function getKnowledgeByIDs(store, ids) {
+	if (ids.length === 0) return [];
+	const placeholders = ids.map(() => "?").join(",");
+	return store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index WHERE id IN (${placeholders})
+  `).all(...ids).map(mapRow);
+}
+function listAllKnowledge(store, projectRemote, projectPath, limit) {
+	return store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index
+    WHERE project_remote = ? AND project_path = ?
+    ORDER BY updated_at DESC LIMIT ?
+  `).all(projectRemote, projectPath, limit).map(mapRow);
+}
+function setKnowledgeEnabled(store, id, enabled) {
+	store.db.prepare("UPDATE knowledge_index SET enabled = ? WHERE id = ?").run(enabled ? 1 : 0, id);
+}
+function incrementHitCount(store, ids) {
+	if (ids.length === 0) return;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const placeholders = ids.map(() => "?").join(",");
+	store.db.prepare(`UPDATE knowledge_index SET hit_count = hit_count + 1, last_accessed = ?
+     WHERE id IN (${placeholders})`).run(now, ...ids);
+}
+function promoteSubType(store, id, newSubType) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	if (store.db.prepare("UPDATE knowledge_index SET sub_type = ?, updated_at = ? WHERE id = ? AND enabled = 1").run(newSubType, now, id).changes === 0) throw new Error(`store: promote sub_type: knowledge ${id} not found or disabled`);
+}
+function getPromotionCandidates(store) {
+	return store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index
+    WHERE enabled = 1
+      AND ((sub_type = 'general' AND hit_count >= 5)
+        OR (sub_type = 'pattern' AND hit_count >= 15))
+    ORDER BY hit_count DESC
+  `).all().map(mapRow);
+}
+function getKnowledgeStats(store) {
+	const agg = store.db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(hit_count), 0) as avg_hits FROM knowledge_index WHERE enabled = 1").get();
+	const bySubType = {};
+	const subtypeRows = store.db.prepare("SELECT sub_type, COUNT(*) as cnt FROM knowledge_index WHERE enabled = 1 GROUP BY sub_type").all();
+	for (const r of subtypeRows) bySubType[r.sub_type] = r.cnt;
+	const topRows = store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index WHERE enabled = 1
+    ORDER BY hit_count DESC LIMIT 5
+  `).all();
+	return {
+		total: agg?.total ?? 0,
+		avgHitCount: agg?.avg_hits ?? 0,
+		bySubType,
+		topAccessed: topRows.map(mapRow)
+	};
+}
+function searchKnowledgeKeyword(store, query, limit) {
+	const escaped = escapeLIKEContains(query);
+	return store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index
+    WHERE enabled = 1 AND (content LIKE ? ESCAPE '\\' OR title LIKE ? ESCAPE '\\')
+    ORDER BY hit_count DESC LIMIT ?
+  `).all(escaped, escaped, limit).map(mapRow);
+}
+function countKnowledge(store, projectRemote, projectPath) {
+	return store.db.prepare("SELECT COUNT(*) as cnt FROM knowledge_index WHERE project_remote = ? AND project_path = ? AND enabled = 1").get(projectRemote, projectPath).cnt;
+}
+function escapeLIKEContains(s) {
+	s = s.replaceAll("\\", "\\\\");
+	s = s.replaceAll("%", "\\%");
+	s = s.replaceAll("_", "\\_");
+	return `%${s}%`;
+}
+function mapRow(r) {
+	return {
+		id: r.id,
+		filePath: r.file_path,
+		contentHash: r.content_hash,
+		title: r.title,
+		content: r.content,
+		subType: r.sub_type,
+		projectRemote: r.project_remote,
+		projectPath: r.project_path,
+		projectName: r.project_name,
+		branch: r.branch,
+		createdAt: r.created_at,
+		updatedAt: r.updated_at,
+		hitCount: r.hit_count,
+		lastAccessed: r.last_accessed,
+		enabled: r.enabled === 1
+	};
+}
+//#endregion
+export { getPromotionCandidates as a, mapRow as c, setKnowledgeEnabled as d, upsertKnowledge as f, getKnowledgeStats as i, promoteSubType as l, getKnowledgeByID as n, incrementHitCount as o, getKnowledgeByIDs as r, listAllKnowledge as s, countKnowledge as t, searchKnowledgeKeyword as u };

package/dist/post-tool-qemgso2b.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { o as readActive, t as SpecDir } from "./types-C3butmI8.mjs";
+import { n as searchKnowledgeFTS } from "./fts-BDdUbNfM.mjs";
+import { emitAdditionalContext, extractSection, notifyUser } from "./dispatcher-BzOdcjaa.mjs";
+import { openDefaultCached } from "./store-Clcihees.mjs";
+import { r as truncate } from "./helpers-BsdW4kgn.mjs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+//#region src/hooks/post-tool.ts
+const EXPLORE_COUNTER_PATH = join(tmpdir(), "alfred-explore-count");
+function readExploreCount() {
+	try {
+		return parseInt(readFileSync(EXPLORE_COUNTER_PATH, "utf-8"), 10) || 0;
+	} catch {
+		return 0;
+	}
+}
+function writeExploreCount(n) {
+	try {
+		writeFileSync(EXPLORE_COUNTER_PATH, String(n));
+	} catch {}
+}
+async function postToolUse(ev, _signal) {
+	if (!ev.cwd || !ev.tool_name) return;
+	if (ev.tool_name === "Read" || ev.tool_name === "Grep" || ev.tool_name === "Glob") {
+		const count = readExploreCount() + 1;
+		writeExploreCount(count);
+		if (count >= 5) try {
+			readActive(ev.cwd);
+		} catch {
+			notifyUser("tip: 5+ consecutive %s calls without a spec. Consider `/alfred:survey` to reverse-engineer a spec from the code.", ev.tool_name);
+			writeExploreCount(0);
+		}
+		return;
+	}
+	writeExploreCount(0);
+	if (ev.tool_name === "Bash") await handleBashResult(ev);
+}
+async function handleBashResult(ev) {
+	const response = ev.tool_response;
+	if (!response) return;
+	if (response.exitCode && response.exitCode !== 0 && response.stderr) {
+		const errorText = typeof response.stderr === "string" ? response.stderr : "";
+		if (errorText.length > 10) await searchErrorContext(ev.cwd, errorText);
+	}
+	if (response.exitCode === 0) autoCheckNextSteps(ev.cwd, response.stdout ?? "");
+}
+async function searchErrorContext(projectPath, errorText) {
+	let store;
+	try {
+		store = openDefaultCached();
+	} catch {
+		return;
+	}
+	const query = errorText.slice(0, 200);
+	try {
+		const docs = searchKnowledgeFTS(store, query, 3);
+		if (docs.length > 0) emitAdditionalContext("PostToolUse", `Related knowledge for this error:\n${docs.map((d) => `- ${d.title}: ${truncate(d.content, 150)}`).join("\n")}`);
+	} catch {}
+}
+function autoCheckNextSteps(projectPath, stdout) {
+	try {
+		const sd = new SpecDir(projectPath, readActive(projectPath));
+		const session = sd.readFile("session.md");
+		const nextStepsSection = extractSection(session, "## Next Steps");
+		if (!nextStepsSection) return;
+		const lines = nextStepsSection.split("\n");
+		let changed = false;
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			const match = line.match(/^- \[ \] (.+)$/);
+			if (!match) continue;
+			const description = match[1].toLowerCase();
+			if (stdout && description.split(/\s+/).some((word) => word.length > 3 && stdout.toLowerCase().includes(word))) {
+				lines[i] = line.replace("- [ ]", "- [x]");
+				changed = true;
+			}
+		}
+		if (changed) {
+			const updatedSection = lines.join("\n");
+			const updatedSession = session.replace(nextStepsSection, updatedSection);
+			sd.writeFile("session.md", updatedSession);
+		}
+	} catch {}
+}
+//#endregion
+export { postToolUse };

package/dist/postinstall.mjs

@@ -0,0 +1,49 @@
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+//#region src/postinstall.ts
+async function main() {
+	const home = homedir();
+	const dbDir = join(home, ".claude-alfred");
+	try {
+		mkdirSync(dbDir, { recursive: true });
+	} catch {}
+	try {
+		const Database = (await import("better-sqlite3")).default;
+		const { migrate } = await import("./schema-CcIFwr_0.mjs");
+		const dbPath = join(dbDir, "alfred.db");
+		const db = new Database(dbPath);
+		db.pragma("journal_mode = WAL");
+		migrate(db);
+		db.close();
+		console.log("[alfred] database ready:", dbPath);
+	} catch (err) {
+		console.error("[alfred] warning: database setup skipped:", err);
+	}
+	const rulesDir = join(home, ".claude", "rules");
+	try {
+		mkdirSync(rulesDir, { recursive: true });
+		if (!readdirSync(rulesDir).some((f) => f.startsWith("alfred-"))) {
+			writeFileSync(join(rulesDir, "alfred.md"), `# alfred MCP Tools
+
+alfred's knowledge base contains extensive curated Claude Code docs and best practices with vector search.
+
+## knowledge — Search docs and best practices
+
+**ALWAYS call knowledge BEFORE** answering questions about Claude Code. Do not guess or rely on training data.
+
+Call when the user's question or task involves ANY of:
+- Hooks, skills, rules, agents, plugins, MCP servers, CLAUDE.md, memory
+- Permissions, settings, compaction, CLI features, IDE integrations
+- Best practices for Claude Code configuration or workflow
+- Evaluating whether code follows Claude Code conventions
+
+Do NOT call for: general programming, project-specific code, non-Claude-Code topics.
+`);
+			console.log("[alfred] rules installed:", rulesDir);
+		}
+	} catch {}
+}
+main().catch(() => {});
+//#endregion
+export {};

package/dist/pre-compact-Cmg9kprV.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import { o as readActive, r as completeTask, s as readActiveState, t as SpecDir } from "./types-C3butmI8.mjs";
+import { o as syncTaskStatus } from "./epic-CdRKNGvP.mjs";
+import { f as upsertKnowledge } from "./knowledge-CCCixwb8.mjs";
+import { t as detectProject } from "./project-CpgK3fwQ.mjs";
+import { notifyUser } from "./dispatcher-BzOdcjaa.mjs";
+import { openDefaultCached } from "./store-Clcihees.mjs";
+import { t as appendAudit } from "./audit-DujZ6YAy.mjs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/hooks/pre-compact.ts
+async function preCompact(ev, _signal) {
+	if (!ev.cwd) return;
+	let store;
+	try {
+		store = openDefaultCached();
+	} catch {
+		return;
+	}
+	const projectPath = ev.cwd;
+	const proj = detectProject(projectPath);
+	if (ev.transcript_path) try {
+		const decisions = extractDecisions(readFileSync(ev.transcript_path, "utf-8"));
+		if (decisions.length > 0) {
+			const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15);
+			for (let idx = 0; idx < decisions.length; idx++) {
+				const dec = decisions[idx];
+				const row = {
+					id: 0,
+					filePath: `decisions/compact/${ts}-${idx}`,
+					contentHash: "",
+					title: dec.title,
+					content: dec.content,
+					subType: "decision",
+					projectRemote: proj.remote,
+					projectPath: proj.path,
+					projectName: proj.name,
+					branch: proj.branch,
+					createdAt: "",
+					updatedAt: "",
+					hitCount: 0,
+					lastAccessed: "",
+					enabled: true
+				};
+				upsertKnowledge(store, row);
+			}
+			notifyUser("extracted %d decisions from transcript", decisions.length);
+		}
+	} catch {}
+	try {
+		const taskSlug = readActive(projectPath);
+		const sd = new SpecDir(projectPath, taskSlug);
+		if (sd.exists()) {
+			const session = sd.readFile("session.md");
+			const chapterNum = (session.match(/## Compact Marker \[/g) ?? []).length + 1;
+			const title = `${proj.name} > ${taskSlug} > chapter-${chapterNum} > session-state`;
+			const row = {
+				id: 0,
+				filePath: `chapters/${taskSlug}/chapter-${chapterNum}`,
+				contentHash: "",
+				title,
+				content: session.slice(0, 2e3),
+				subType: "general",
+				projectRemote: proj.remote,
+				projectPath: proj.path,
+				projectName: proj.name,
+				branch: proj.branch,
+				createdAt: "",
+				updatedAt: "",
+				hitCount: 0,
+				lastAccessed: "",
+				enabled: true
+			};
+			upsertKnowledge(store, row);
+			const breadcrumb = {
+				claude_session_id: process.env["CLAUDE_SESSION_ID"] ?? "",
+				task_slug: taskSlug,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			writeFileSync(join(projectPath, ".alfred", ".pending-compact.json"), JSON.stringify(breadcrumb));
+		}
+	} catch {}
+	try {
+		const taskSlug = readActive(projectPath);
+		if (isSessionCompleted(new SpecDir(projectPath, taskSlug).readFile("session.md"))) {
+			completeTask(projectPath, taskSlug);
+			syncTaskStatus(projectPath, taskSlug, "completed");
+			appendAudit(projectPath, {
+				action: "spec.complete",
+				target: taskSlug,
+				detail: "auto-completed during compact",
+				user: "auto"
+			});
+			notifyUser("auto-completed task '%s'", taskSlug);
+		}
+	} catch {}
+	try {
+		const state = readActiveState(projectPath);
+		for (const task of state.tasks) if (task.status === "completed") syncTaskStatus(projectPath, task.slug, "completed");
+	} catch {}
+}
+const DECISION_KEYWORDS = [
+	"decided",
+	"決定した",
+	"going with",
+	"we'll",
+	"chose",
+	"chosen",
+	"architecture",
+	"アーキテクチャ",
+	"design choice",
+	"decided to"
+];
+const RATIONALE_SIGNALS = [
+	"because",
+	"since",
+	"reason",
+	"rationale",
+	"なぜなら",
+	"理由"
+];
+const ALTERNATIVE_SIGNALS = [
+	"instead of",
+	"rather than",
+	"alternative",
+	"considered",
+	"代わりに"
+];
+const ARCH_TERMS = [
+	"component",
+	"module",
+	"layer",
+	"service",
+	"interface",
+	"pattern",
+	"migration"
+];
+function extractDecisions(transcript) {
+	const decisions = [];
+	const lines = transcript.split("\n");
+	for (const line of lines) {
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		const text = typeof entry.content === "string" ? entry.content : typeof entry.message?.content === "string" ? entry.message.content : "";
+		if (!text) continue;
+		if ((entry.role ?? entry.message?.role) !== "assistant") continue;
+		const lower = text.toLowerCase();
+		let score = 0;
+		for (const kw of DECISION_KEYWORDS) if (lower.includes(kw)) {
+			score = .35;
+			break;
+		}
+		if (score === 0) continue;
+		if (RATIONALE_SIGNALS.some((s) => lower.includes(s))) score += .15;
+		if (ALTERNATIVE_SIGNALS.some((s) => lower.includes(s))) score += .15;
+		for (const term of ARCH_TERMS) if (lower.includes(term)) {
+			score += .05;
+			break;
+		}
+		if (score < .4) continue;
+		const firstSentence = text.split(/[.!?\n]/)[0]?.trim() ?? "Decision";
+		decisions.push({
+			title: firstSentence.slice(0, 100),
+			content: text.slice(0, 1e3)
+		});
+	}
+	return decisions;
+}
+function isSessionCompleted(session) {
+	const lower = session.toLowerCase();
+	if (lower.includes("status: completed") || lower.includes("status: done")) return true;
+	const nextSteps = session.match(/^- \[[ x]\] .+$/gm);
+	if (!nextSteps || nextSteps.length === 0) return false;
+	return nextSteps.every((step) => step.startsWith("- [x]"));
+}
+//#endregion
+export { preCompact };

package/dist/project-CpgK3fwQ.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { basename, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+//#region src/store/project.ts
+function detectProject(dirPath) {
+	const absPath = resolve(dirPath);
+	const info = {
+		path: absPath,
+		name: basename(absPath),
+		remote: "",
+		branch: ""
+	};
+	info.remote = detectGitRemote(absPath);
+	info.branch = detectGitBranch(absPath);
+	if (info.remote) {
+		const name = repoNameFromRemote(info.remote);
+		if (name) info.name = name;
+	}
+	return info;
+}
+function detectGitRemote(dir) {
+	try {
+		return normalizeRemoteURL(execFileSync("git", [
+			"-C",
+			dir,
+			"remote",
+			"get-url",
+			"origin"
+		], {
+			timeout: 500,
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim());
+	} catch {
+		return "";
+	}
+}
+function detectGitBranch(dir) {
+	try {
+		return execFileSync("git", [
+			"-C",
+			dir,
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], {
+			timeout: 500,
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+function normalizeRemoteURL(raw) {
+	let s = raw;
+	if (s.startsWith("git@")) {
+		s = s.slice(4);
+		s = s.replace(":", "/");
+	}
+	s = s.replace(/^https?:\/\//, "");
+	s = s.replace(/\.git$/, "");
+	s = s.replace(/\/$/, "");
+	return s;
+}
+function repoNameFromRemote(remote) {
+	const parts = remote.split("/");
+	return parts[parts.length - 1] ?? "";
+}
+//#endregion
+export { detectProject as t };