@clubnet/seedclub 0.2.0

package/assets/extensions/seedclub-ui/update.ts

@@ -0,0 +1,73 @@
+/**
+ * Update check — runs on session start, notifies if a new version is available.
+ * To update, run `seedclub update` in your terminal.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { readFileSync, existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface VersionInfo {
+	seedclubVersion: string;
+	piVersion: string;
+}
+
+function compareSemver(a: string, b: string): number {
+	const pa = a.trim().split(".").map((x) => Number.parseInt(x, 10));
+	const pb = b.trim().split(".").map((x) => Number.parseInt(x, 10));
+	if (pa.some(Number.isNaN) || pb.some(Number.isNaN)) return a.localeCompare(b);
+	const len = Math.max(pa.length, pb.length);
+	for (let i = 0; i < len; i++) {
+		const av = pa[i] ?? 0;
+		const bv = pb[i] ?? 0;
+		if (av > bv) return 1;
+		if (av < bv) return -1;
+	}
+	return 0;
+}
+
+function getInstalledVersion(): VersionInfo | null {
+	const versionFile = join(homedir(), ".seedclub", "agent", ".seedclub-version");
+	if (!existsSync(versionFile)) return null;
+	try {
+		return JSON.parse(readFileSync(versionFile, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+
+function getLatestVersion(): Promise<string | null> {
+	return new Promise((resolve) => {
+		execFile("npm", ["view", "@clubnet/seedclub", "version"], { timeout: 10000 }, (err, stdout) => {
+			if (err) return resolve(null);
+			const version = stdout.trim();
+			resolve(version || null);
+		});
+	});
+}
+
+export default function (pi: ExtensionAPI) {
+	// Check for updates on session start (background, non-blocking)
+	pi.on("session_start", async (_event, ctx) => {
+		if (!ctx.hasUI) return;
+
+		const installed = getInstalledVersion();
+		if (!installed) return;
+
+		try {
+			const latest = await getLatestVersion();
+			if (!latest) return;
+
+			if (compareSemver(latest, installed.seedclubVersion) > 0) {
+				ctx.ui.setWidget("seedclub-update", [
+					`⚡ seedclub v${latest} available (current: v${installed.seedclubVersion})`,
+					`   Run: seedclub update`,
+				]);
+			}
+		} catch {
+			// Silent — no network is fine
+		}
+	});
+}

package/assets/extensions/seedclub-ui/welcome.ts

@@ -0,0 +1,250 @@
+/**
+ * Welcome header with live weather + market data.
+ * /commands and /extensions still available as commands.
+ */
+
+import { execFileSync } from "node:child_process";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const EMERALD = "\x1b[38;2;80;200;120m";
+const DODGER = "\x1b[38;2;30;144;255m";
+const RED = "\x1b[38;2;255;0;0m";
+const DIM = "\x1b[38;2;85;85;85m";
+const WHITE = "\x1b[38;2;200;200;200m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+interface MarketQuote {
+	symbol: string;
+	price: string;
+	change: string;
+	pct: string;
+}
+
+interface WeatherData {
+	temp: string;
+	condition: string;
+	location: string;
+	icon: string;
+}
+
+let cachedWeather: WeatherData | null = null;
+let cachedMarket: MarketQuote[] | null = null;
+let lastFetch = 0;
+const CACHE_MS = 10 * 60 * 1000;
+
+function getCityFromTimezone(): string {
+	try {
+		const tz = execFileSync("readlink", ["/etc/localtime"], { encoding: "utf-8" }).trim();
+		const parts = tz.replace(/.*\/zoneinfo\//, "").split("/");
+		return parts[parts.length - 1]!.replace(/_/g, " ");
+	} catch {
+		return "New York";
+	}
+}
+
+async function fetchWeather(): Promise<WeatherData> {
+	try {
+		const city = getCityFromTimezone();
+		const res = await fetch(`https://wttr.in/${encodeURIComponent(city)}?format=j1`, {
+			headers: { "User-Agent": "curl/7.0" },
+			signal: AbortSignal.timeout(5000),
+		});
+		const data = (await res.json()) as any;
+		const current = data.current_condition?.[0];
+
+		const icons: Record<string, string> = {
+			Sunny: "☀",
+			Clear: "☀",
+			"Partly cloudy": "⛅",
+			"Partly Cloudy": "⛅",
+			Cloudy: "☁",
+			Overcast: "☁",
+			Mist: "🌫",
+			Fog: "🌫",
+			"Light rain": "🌧",
+			Rain: "🌧",
+			"Heavy rain": "🌧",
+			"Light snow": "❄",
+			Snow: "❄",
+			Thunderstorm: "⛈",
+		};
+		const desc = current?.weatherDesc?.[0]?.value || "Unknown";
+
+		return {
+			temp: `${current?.temp_F || "?"}°F`,
+			condition: desc,
+			location: city,
+			icon: icons[desc] || "🌡",
+		};
+	} catch {
+		return { temp: "—", condition: "unavailable", location: "—", icon: "🌡" };
+	}
+}
+
+async function fetchMarket(): Promise<MarketQuote[]> {
+	const symbols = [
+		{ sym: "SPY", name: "S&P 500" },
+		{ sym: "QQQ", name: "Nasdaq" },
+		{ sym: "BTC-USD", name: "BTC" },
+		{ sym: "ETH-USD", name: "ETH" },
+	];
+
+	const quotes: MarketQuote[] = [];
+	for (const { sym, name } of symbols) {
+		try {
+			const url = `https://query1.finance.yahoo.com/v8/finance/chart/${sym}?range=1d&interval=1d`;
+			const res = await fetch(url, {
+				headers: { "User-Agent": "Mozilla/5.0" },
+				signal: AbortSignal.timeout(5000),
+			});
+			const data = (await res.json()) as any;
+			const meta = data?.chart?.result?.[0]?.meta;
+			const price = meta?.regularMarketPrice ?? 0;
+			const prevClose = meta?.chartPreviousClose ?? meta?.previousClose ?? price;
+			const change = price - prevClose;
+			const pct = prevClose > 0 ? (change / prevClose) * 100 : 0;
+
+			quotes.push({
+				symbol: name,
+				price: price > 1000 ? price.toFixed(0) : price.toFixed(2),
+				change: change >= 0 ? `+${change.toFixed(2)}` : change.toFixed(2),
+				pct: `${pct >= 0 ? "+" : ""}${pct.toFixed(2)}%`,
+			});
+		} catch {
+			quotes.push({ symbol: name, price: "—", change: "—", pct: "—" });
+		}
+	}
+	return quotes;
+}
+
+async function getData() {
+	const now = Date.now();
+	if (cachedWeather && cachedMarket && now - lastFetch < CACHE_MS) {
+		return { weather: cachedWeather, market: cachedMarket };
+	}
+	const [weather, market] = await Promise.all([fetchWeather(), fetchMarket()]);
+	cachedWeather = weather;
+	cachedMarket = market;
+	lastFetch = now;
+	return { weather, market };
+}
+
+function formatQuote(q: MarketQuote): string {
+	const color = q.change.startsWith("+") ? EMERALD : q.change.startsWith("-") ? RED : DIM;
+	return `${WHITE}${q.symbol}${RESET} ${DIM}${q.price}${RESET} ${color}${q.pct}${RESET}`;
+}
+
+const EMERALD_ANSI = "\x1b[38;2;80;200;120m";
+
+export default function (pi: ExtensionAPI, options?: { enableFrame?: boolean }) {
+	let headerLines: string[] = [
+		"",
+		`  ${EMERALD}${BOLD}The Human+ Venture Network${RESET}`,
+		"",
+		`  ${DIM}loading...${RESET}`,
+		"",
+	];
+
+	pi.on("session_start", async (_event, ctx) => {
+		if (!ctx.hasUI) return;
+
+		let tuiRef: any = null;
+
+		ctx.ui.setHeader((tui, _theme) => {
+			tuiRef = tui;
+
+			// Enable window frame around entire TUI (footer excluded)
+			if (options?.enableFrame && tui.setFrame) {
+				tui.setFrame({
+					enabled: true,
+					inset: 1,
+					excludeBottom: 3,
+					borderColor: (s: string) => `${EMERALD_ANSI}${s}\x1b[0m`,
+				});
+			}
+
+			return {
+				render(_width: number): string[] {
+					return headerLines;
+				},
+				invalidate() {},
+			};
+		});
+
+		try {
+			const { weather, market } = await getData();
+			const weatherLine = `  ${weather.icon} ${WHITE}${weather.temp}${RESET} ${DIM}${weather.condition}${RESET}  ${DIM}·${RESET}  ${DIM}${weather.location}${RESET}`;
+			const marketLine = `  ${market.map(formatQuote).join(`  ${DIM}·${RESET}  `)}`;
+
+			headerLines = [
+				"",
+				`  ${EMERALD}${BOLD}The Human+ Venture Network${RESET}`,
+				"",
+				weatherLine,
+				marketLine,
+				"",
+				`  ${DIM}type ${WHITE}/${RESET}${DIM} to see commands${RESET}`,
+				"",
+			];
+			tuiRef?.requestRender();
+		} catch {
+			headerLines = [
+				"",
+				`  ${EMERALD}${BOLD}The Human+ Venture Network${RESET}`,
+				"",
+				`  ${DIM}type ${WHITE}/${RESET}${DIM} to see commands${RESET}`,
+				"",
+			];
+			tuiRef?.requestRender();
+		}
+	});
+
+	pi.registerCommand("commands", {
+		description: "List all available commands",
+		handler: async (_args, _ctx) => {
+			const commands = pi.getCommands();
+			const lines = commands
+				.sort((a, b) => a.name.localeCompare(b.name))
+				.map((cmd) => `  ${EMERALD}/${cmd.name}${RESET}  ${DIM}${cmd.description || ""}${RESET}`)
+				.join("\n");
+			pi.sendMessage({
+				customType: "info-display",
+				content: `${BOLD}${WHITE}Commands${RESET}\n\n${lines}`,
+				display: true,
+			});
+		},
+	});
+
+	pi.registerCommand("extensions", {
+		description: "List loaded extensions",
+		handler: async (_args, _ctx) => {
+			const commands = pi.getCommands();
+			const extPaths = new Map<string, string[]>();
+			for (const cmd of commands) {
+				if (cmd.source === "extension" && cmd.path) {
+					const name = cmd.path.replace(/.*\/extensions\//, "").replace(/\.ts$/, "");
+					if (!extPaths.has(name)) extPaths.set(name, []);
+					extPaths.get(name)!.push(cmd.name);
+				}
+			}
+			let lines: string;
+			if (extPaths.size > 0) {
+				lines = [...extPaths.entries()]
+					.sort(([a], [b]) => a.localeCompare(b))
+					.map(([name, cmds]) => {
+						const cmdList = cmds.map((c) => `${DIM}/${c}${RESET}`).join(" ");
+						return `  ${DODGER}${name}${RESET}  ${cmdList}`;
+					})
+					.join("\n");
+			} else {
+				lines = `  ${DIM}No extension commands registered${RESET}`;
+			}
+			pi.sendMessage({
+				customType: "info-display",
+				content: `${BOLD}${WHITE}Extensions${RESET}\n\n${lines}`,
+				display: true,
+			});
+		},
+	});
+}

package/assets/theme/seedclub.json

@@ -0,0 +1,86 @@
+{
+	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "seedclub",
+	"vars": {
+		"brand": "#00C853",
+		"brandDim": "#00963F",
+		"brandLight": "#69F0AE",
+		"warmWhite": "#E8E6E3",
+		"coolGray": "#8A8F98",
+		"dimGray": "#5C6370",
+		"darkGray": "#3E4451",
+		"deepBg": "#1A1D23",
+		"cardBg": "#21252B",
+		"surfaceBg": "#282C34",
+		"red": "#E06C75",
+		"yellow": "#E5C07B",
+		"blue": "#61AFEF",
+		"purple": "#C678DD",
+		"cyan": "#56B6C2",
+		"green": "#98C379"
+	},
+	"colors": {
+		"accent": "brand",
+		"border": "brandDim",
+		"borderAccent": "brandLight",
+		"borderMuted": "darkGray",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "coolGray",
+		"dim": "dimGray",
+		"text": "",
+		"thinkingText": "coolGray",
+
+		"selectedBg": "#2C3340",
+		"userMessageBg": "surfaceBg",
+		"userMessageText": "",
+		"customMessageBg": "cardBg",
+		"customMessageText": "",
+		"customMessageLabel": "brand",
+		"toolPendingBg": "deepBg",
+		"toolSuccessBg": "#1A2E1A",
+		"toolErrorBg": "#2E1A1A",
+		"toolTitle": "brandLight",
+		"toolOutput": "coolGray",
+
+		"mdHeading": "yellow",
+		"mdLink": "blue",
+		"mdLinkUrl": "dimGray",
+		"mdCode": "cyan",
+		"mdCodeBlock": "green",
+		"mdCodeBlockBorder": "coolGray",
+		"mdQuote": "coolGray",
+		"mdQuoteBorder": "coolGray",
+		"mdHr": "darkGray",
+		"mdListBullet": "brand",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "coolGray",
+
+		"syntaxComment": "#7F848E",
+		"syntaxKeyword": "purple",
+		"syntaxFunction": "blue",
+		"syntaxVariable": "red",
+		"syntaxString": "green",
+		"syntaxNumber": "#D19A66",
+		"syntaxType": "cyan",
+		"syntaxOperator": "warmWhite",
+		"syntaxPunctuation": "coolGray",
+
+		"thinkingOff": "darkGray",
+		"thinkingMinimal": "dimGray",
+		"thinkingLow": "brandDim",
+		"thinkingMedium": "brand",
+		"thinkingHigh": "brandLight",
+		"thinkingXhigh": "#B9F6CA",
+
+		"bashMode": "yellow"
+	},
+	"export": {
+		"pageBg": "#1A1D23",
+		"cardBg": "#21252B",
+		"infoBg": "#2A2D25"
+	}
+}

package/bin/cli.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execFileSync, spawn } = require("child_process");
+const { readFileSync, existsSync, writeFileSync, unlinkSync } = require("fs");
+const { join, dirname } = require("path");
+const { homedir } = require("os");
+const readline = require("readline");
+
+const SC_DIR = join(homedir(), ".seedclub", "agent");
+const VERSION_FILE = join(SC_DIR, ".seedclub-version");
+
+function printPrivateRegistryHint() {
+	console.error("seedclub: install/update failed.");
+	console.error("This package is private on npmjs.");
+	console.error("Configure npm auth, then retry:");
+	console.error("  seedclub setup-auth");
+	console.error("Or run with an ephemeral token:");
+	console.error("  SEEDCLUB_NPM_TOKEN=YOUR_NPM_TOKEN seedclub update");
+}
+
+function upsertLine(lines, prefix, value) {
+	const idx = lines.findIndex((line) => line.trim().startsWith(prefix));
+	if (idx >= 0) {
+		lines[idx] = value;
+	} else {
+		lines.push(value);
+	}
+}
+
+function readNpmrcLines(path) {
+	if (!existsSync(path)) return [];
+	const raw = readFileSync(path, "utf-8");
+	if (!raw.trim()) return [];
+	return raw.split(/\r?\n/).filter((line) => line.length > 0);
+}
+
+function askHidden(prompt) {
+	return new Promise((resolve, reject) => {
+		if (!process.stdin.isTTY || !process.stdout.isTTY) {
+			return reject(new Error("Interactive prompt requires a TTY"));
+		}
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout,
+			terminal: true,
+		});
+		const onData = (char) => {
+			const ch = String(char);
+			if (ch === "\n" || ch === "\r" || ch === "\u0004") {
+				process.stdout.write("\n");
+			} else if (ch === "\u0003") {
+				process.stdout.write("^C\n");
+			} else {
+				process.stdout.write("\x1b[2K\x1b[200D" + prompt + "*".repeat(rl.line.length));
+			}
+		};
+		process.stdin.on("data", onData);
+		rl.question(prompt, (value) => {
+			process.stdin.removeListener("data", onData);
+			rl.close();
+			resolve(value.trim());
+		});
+		rl.on("SIGINT", () => {
+			process.stdin.removeListener("data", onData);
+			rl.close();
+			reject(new Error("Cancelled"));
+		});
+	});
+}
+
+async function setupAuth() {
+	const npmrcPath = join(homedir(), ".npmrc");
+	let token = process.env.SEEDCLUB_NPM_TOKEN || process.env.NPM_TOKEN || "";
+	if (!token) {
+		try {
+			token = await askHidden("npm token: ");
+		} catch (err) {
+			console.error(`seedclub: ${err.message}`);
+			process.exit(1);
+		}
+	}
+	if (!token) {
+		console.error("seedclub: no token provided.");
+		process.exit(1);
+	}
+
+	const lines = readNpmrcLines(npmrcPath);
+	upsertLine(lines, "@clubnet:registry=", "@clubnet:registry=https://registry.npmjs.org/");
+	upsertLine(lines, "//registry.npmjs.org/:_authToken=", `//registry.npmjs.org/:_authToken=${token}`);
+	writeFileSync(npmrcPath, lines.join("\n") + "\n", { mode: 0o600 });
+
+	console.log(`Wrote npm auth config to ${npmrcPath}`);
+	console.log("You can now run:");
+	console.log("  npm install -g @clubnet/seedclub");
+}
+
+function withOptionalEphemeralNpmrc(run) {
+	const token = process.env.SEEDCLUB_NPM_TOKEN || process.env.NPM_TOKEN;
+	if (!token) return run([]);
+
+	const npmrcPath = join(SC_DIR, ".npmrc.tmp");
+	try {
+		writeFileSync(
+			npmrcPath,
+			`@clubnet:registry=https://registry.npmjs.org/\n//registry.npmjs.org/:_authToken=${token}\n`,
+			{ mode: 0o600 },
+		);
+		return run(["--userconfig", npmrcPath]);
+	} finally {
+		try {
+			unlinkSync(npmrcPath);
+		} catch {}
+	}
+}
+
+// ── Subcommands ──────────────────────────────────────────────────────────
+
+const cmd = process.argv[2];
+
+if (cmd === "version") {
+	if (existsSync(VERSION_FILE)) {
+		try {
+			const info = JSON.parse(readFileSync(VERSION_FILE, "utf-8"));
+			console.log(`seedclub v${info.seedclubVersion}`);
+		} catch {
+			console.log("seedclub (version unknown)");
+		}
+	} else {
+		console.log("seedclub (version unknown)");
+	}
+	process.exit(0);
+}
+
+if (cmd === "setup-auth") {
+	setupAuth().catch((err) => {
+		console.error(`seedclub: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	});
+}
+
+if (cmd === "update") {
+	try {
+		withOptionalEphemeralNpmrc((extraArgs) => {
+			execFileSync("npm", ["install", "-g", "@clubnet/seedclub@latest", ...extraArgs], {
+				stdio: "inherit",
+			});
+		});
+	} catch {
+		printPrivateRegistryHint();
+		process.exit(1);
+	}
+	process.exit(0);
+}
+
+if (cmd !== "setup-auth") {
+	// ── Resolve pi binary ───────────────────────────────────────────────────
+
+	let piBin;
+	try {
+		const piPkgPath = require.resolve(
+			"@mariozechner/pi-coding-agent/package.json",
+		);
+		const piPkg = JSON.parse(readFileSync(piPkgPath, "utf-8"));
+		const binEntry = piPkg.bin && (piPkg.bin.pi || Object.values(piPkg.bin)[0]);
+		if (!binEntry) throw new Error("No bin entry in pi package.json");
+		piBin = join(dirname(piPkgPath), binEntry);
+	} catch (err) {
+		console.error("seedclub: could not locate pi runtime. Reinstall with:");
+		console.error("  npm install -g @clubnet/seedclub");
+		process.exit(1);
+	}
+
+	// ── Environment ─────────────────────────────────────────────────────────
+
+	process.env.PI_CODING_AGENT_DIR = SC_DIR;
+	process.env.PI_SKIP_VERSION_CHECK = "1";
+	process.env.NODE_OPTIONS = `--no-warnings ${process.env.NODE_OPTIONS || ""}`.trim();
+
+	// ── Spawn pi ────────────────────────────────────────────────────────────
+
+	const args = process.argv.slice(2);
+	const child = spawn(process.execPath, [piBin, ...args], {
+		stdio: "inherit",
+		env: process.env,
+	});
+
+	child.on("exit", (code, signal) => {
+		if (signal) {
+			process.kill(process.pid, signal);
+		} else {
+			process.exit(code ?? 1);
+		}
+	});
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@clubnet/seedclub",
+  "version": "0.2.0",
+  "description": "The Human+ Venture Network — AI agent for deal sourcing, research, and signal tracking",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/seedclub/seedclub.git"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "bin": {
+    "seedclub": "bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "0.52.9"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "bin/",
+    "assets/",
+    "postinstall.js"
+  ]
+}